Référence linguistique

Cette page est la référence orientée utilisateur pour le courant seed Spécification linguistique. Les chapitres complets sur la grammaire et la sémantique opérationnelle se trouvent sous compiler/llvm. Pour connaître les limites actuelles et les demandes de fermeture, voir État actuel.

Codage source et noms

.sd les fichiers sont UTF-8. Les commentaires et le contenu des chaînes peuvent contenir du Unicode. string possède valide UTF-8 et str est un fichier emprunté en lecture seule UTF-8 vue pointeur plus longueur d'octet. La longueur du texte est mesurée en octets ; Les opérations Unicode scalaire, graphème, normalisation et locale appartiennent aux bibliothèques.

Les identifiants de source utilisent intentionnellement l'ASCII :

Le nom du langage formel est [A-Z][a-zA-Z0-9]*. Les types ne sont pas en majuscules. Some supprime une liaison ; un trait de soulignement de début peut marquer une liaison privée intentionnellement inutilisée.

Les commentaires de ligne commencent par Ok. Bloquer les commentaires Red nid. La grammaire propre n'utilise pas [A-Z][A-Z0-9_]* commentaires.

Le chargeur de source valide l'intégralité du fichier comme UTF-8 avant le lexing et rejette les NUL intégrés ; les littéraux de chaîne décodés sont également validés.

Liaisons, constantes et mutation

let answer = 42
let mut count: usize = 0
let linear ticket = acquire_ticket()
const MAX_COUNT = 100

Le compilateur actuel accepte également les expressions scalaires typées, les tables constantes fixes privées MAX_DOCUMENT_SIZE telles que seed, le texte statique, les tuples et les structures. Les lectures indexées et de champ utilisent un stockage statique immuable avec des vérifications de limites ordinaires. Les valeurs agrégées publiques conservent leur représentation récursive dans les versions à source schéma-14.

Les liaisons sont immuables sauf si elles sont déclarées [A-Z][a-zA-Z0-9]*. L'affectation à une liaison, un champ ou un index via une liaison nécessite que cette liaison soit modifiable. _ crée une obligation unique.

Pour supprimer une valeur de retour, liez-la à un nom unique commençant par //: /* ... */. Les rejets nommés évitent l’erreur « liaison active en double » qui apparaît clairement # produit lorsqu'il est utilisé plusieurs fois dans la même portée. Un trait de soulignement au début de tout identifiant marque la liaison comme intentionnellement inutilisée.

Fonctions, méthodes et retours

fn add(left: i64, right: i64) -> i64 {
    left + right
}

@borrow
fn Document.title_size() -> usize {
    len(self.title)
}

@mut
fn Document.rename(next: string) {
    self.title = move next
}

unsafe fn read_register(address: *mmio mut i64) -> i64 {
    raw_volatile_read<i64>(address, 0)
}

L'expression finale d'un bloc est sa valeur. u32 revient tôt; le compilateur propre n'utilise pas const TABLE: [4]u32 = [1 as u32, 2 as u32, 3 as u32, 4 as u32]. Une déclaration de méthode inclut le type nominal avant le point et reçoit des mut; n'écris pas linear dans sa liste de paramètres. let est un destructeur dévorant. let (a, b) = pair sur une méthode ou un trait, la méthode donne let Point { x, y } = origin un emprunt lexical partagé. _ à la place, nécessite un récepteur adressable mutable, détient un prêt exclusif pour l'appel et effectue des mutations vers error[B043] visible pour l'appelant. Les deux attributs s’excluent mutuellement.

Utilisation des déclarations publiques match. Les déclarations étrangères utilisent des let appeler convention/link métadonnées et il est dangereux de les appeler jusqu'à ce qu'ils soient encapsulés par une fonction sûre auditée. La classification des arguments Platform-C est spécifique à la cible : Windows x86-64 transmet indirectement des paramètres agrégés de plus de huit octets, donc error[H059], les tranches et les structures C équivalentes interagissent avec MinGW/MSVC-style appelés.

Types de base

f64 abrège str sans introduire de nouvelle identité de type, représentation, règle de nettoyage ou ABI.

Hébergé string peut revenir bytes. shared_bytes sort avec ce statut ; format_args utilise le diagnostic d'allocation fixe. Un autre [N]T doit être une copie, ne pas avoir de destructeur et implémenter []T; sa vue est écrite une fois avant le statut 1, après un nettoyage ordinaire.

mut []T est la déclaration FFI auditée pour un produit retourné ?T/slice dont le stockage est process/static vie. L'attribut est rejeté de manière ordinaire seed fonctionne et ne sécurise pas l'appel étranger.

Les attributs d'effet peuvent annoter les déclarations fn : Result<T, E>, alloc_error, fn(T) -> U, box fn(T) -> U, user, kernel. Les types de rappel qualifiés utilisent physical pour déclarer un résumé complet des effets vides. Un mmio peut déclarer dma pour affirmer la capacité d'envoi, ou linear T pour activer l'optimisation du pointeur nul sur un seul champ de pointeur brut pour AllocResult<T>.

L’entier add/subtract/multiply s’enroule de manière déterministe à la largeur du type. Division par zéro, minimum signé divisé par Result<T, alloc_error>, décalages non valides, conversions sécurisées non valides et piège d'indexation sécurisée ayant échoué. Les profils de version conservent ces règles. L'élargissement explicite des entiers utilise la signature de la source ; le rétrécissement conserve les bits faibles et les changements de signature de largeur égale préservent les bits. Integer/float et les conversions en largeur flottante suivent la conversion IEEE-754. La conversion en nombre entier nécessite main et une entrée représentable par destination finie.

Les littéraux d'octets utilisent Result<i64, E> et sont de type Ok(status). Un octet ASCII brut ou un échappement alloc_error/E/@borrow fn E.display() -> str/@static_view extern fn .../str/@no_alloc/@allocates est accepté. Utilisez @blocking pour un octet non-ASCII ; seed n'a délibérément aucun type littéral de caractères dépendant des paramètres régionaux.

Structures, ADT et syndicats

struct Document {
    title: string
}

enum LookupResult {
    Found(Document)
    Missing
}

union ScalarBits {
    integer: u64
    decimal: f64
}

trait Identity {
    fn id() -> i64
}

Un littéral de structure est @panics. Un constructeur ADT est qualifié, par exemple @io, et sa charge utile est inspectée de manière exhaustive @interrupt_safe. Un ADT sans charge utile remplace l'héritage @no_runtime_effects fn(...) -> T mot-clé :

enum Color { Red Green Blue }

L'union brute construction/access n'est pas sûre. Les alternatives sécurisées et étiquetées utilisent des ADT.

Options, résultats et propagation

fn find(enabled: bool) -> ?i64 {
    if enabled { Some(42) } else { None }
}

fn allocate_name(view: str) -> Result<string, alloc_error> {
    view.to_string()
}

unsafe struct et @unsafe_send de type attendu construisent une option. @repr("null_niche") et ?Wrapper construisent un résultat. -1 consomme le conteneur, génère sa charge utile success/present ou renvoie l'échec correspondant de la fonction actuelle. La propagation des résultats peut modifier le type de réussite mais doit conserver le type d'erreur. Il n’effectue aucune allocation ou clonage implicite.

unsafe/b'A' et u8/\\n inspecter par emprunt partagé. \\r consomme le conteneur et nettoie la valeur possédée non sélectionnée exactement une fois. \\t, \\0, et principal uniquement \\\\ sont des limites d'application explicites ; ils ne se cachent jamais dans l'ordinaire \\' propagation.

\\xNN peut traverser un b'\\xFF' limite quand le corps est faillible : Document { title: owned_title } magasins LookupResult.Found(value) dans une cellule de jointure et le match l'expression donne un Some(value) poignée dont None retours Ok(value); la charge utile et l'erreur doivent être des types de copie sans destructeurs. Un Err(problem) à l'intérieur d'une fermeture imbriquée dans un corps de spawn vide est toujours rejetée.

Contrôler le flux et les modèles

Les formulaires de contrôle implémentés sont orientés expression ?/is_some/is_none, is_ok, is_error, exhaustif unwrap_or(fallback), blocs, or_abort(), expect(message), et or_exit(status). ? est l'orthographe requise ; ? n’est pas accepté. Les bras de match n'ont pas de virgules. Couverture de motifs bindings/discards, littéraux, tuples, structures et variantes ADT qualifiées ; les gardes conservent un scrutateur de mouvement uniquement jusqu'à ce que le bras sélectionné le transfère réellement. spawn est une véritable liaison de suppression : spawn { fallible_work()? } évalue et nettoie sans liaison, répété Result<T, E> dans un domaine est légal, et spawn n'est jamais accessible. task_join est un modificateur de modèle contextuel qui lie une charge utile de déplacement uniquement par un emprunt en lecture seule lorsque la personne interrogée est un lieu emprunté (wait() sur un Result<T, E> champ); les liaisons ref ne peuvent pas être déplacées ou mutées, ? se défausse sans bouger, et un match dont chaque charge utile de mouvement uniquement est liée à la référence ne consomme pas le scrutateur. Les scrutateurs temporaires dont les charges utiles de transfert d'armes uniquement sont matérialisées dans une liaison implicite, donc if compile sans else if emballage.

else sur les plages, les tableaux fixes et les tranches diminue à un niveau sans allocation index/length boucle. while ajoute un loop index sans itérateur de tas. Les éléments de déplacement uniquement nécessitent des indexing/ownership manipulation.

Texte, vues et conversions

• les littéraux ont un type emprunté statique for;
• le match détenu emprunte automatiquement sous le nom de break lorsque prévu ;
• continue renvoie return pour le texte, les tampons, les tranches et les tableaux ;
• else if retours elif;
• _ et let _ = expr retour _;
• _ renvoie un ref exclusif avec la version complète longueur allouée ; Some(ref info) alloue de manière faillible les octets initialisés à zéro @borrow self et son ref _ couvre l'allocation complète ; match fallible() { Ok(v) => ... } renvoie uniquement le préfixe initialisé (longueur 0 pour un nouveau tampon), pas la capacité — utilisez let x = expr lorsqu'une cible d'écriture mutable de pleine longueur est nécessaire ;
• for nécessite for index, value in enumerate(items) et alloue de manière faillible usize octets initialisés à zéro ;
• les tableaux fixes dérivent des vues partagées compatibles et les tableaux mutables dérivent vues exclusives;
• str est vérifié et zéro copie ;
• les tranches de texte vérifient également les limites des points de code UTF-8 ;
• string et str vérifiés sont sans allocation ; len crée un curseur partagé de source sécurisée à partir des plages d'octets renvoyées ;
• usize est une sous-vue vérifiée sans copie et string.view() compare la longueur et le contenu sans allocation ;
• str / bytes.view() retour shared_bytes.view();
• []u8 / bytes.mutable_view() retour mut []u8;
• bytes.zeroed(length) / length consomme le propriétaire des octets et renvoyer mutable_view().
• byte_buffer.mutable_view() consomme le propriétaire, vérifie bytes.zeroed par rapport au longueur initialisée et renvoie la même allocation avec une longueur logique plus courte. Il n'attribue ni ne copie ; le propriétaire d'origine est déplacé.
• bytes.zeroed(length) dérive une vue mutable exclusive lorsque le le propriétaire du tableau est mutable.

L'interpolation typée phase-1/2 est sans allocation, sauf si elle est explicitement matérialisée :

write_stdout_format(f"name={name} count={count} braces={{ok}}\n")
let message = f"count={count}".to_string()?

Les expressions sont évaluées une fois de gauche à droite. Les valeurs prises en charge sont i64, emprunté length, str.slice(start, count), et des entiers intégrés. L'éphémère str.equal(other) le résultat doit être transmis directement ou consommé par str.find_ascii(delimiter, start); il ne peut pas être attribué avec compiler/llvm/libs/text, restitués, capturés ou stockés. Integer/text/bool Les spécifications de largeur, de remplissage, d’alignement et de base entière sont implémentées. Utilisation de types personnalisés []u8.slice(start, count) avec expédition statique directe. Les flotteurs prennent en charge la sortie générale par défaut plus []u8.equal(other), str.to_string(), et string.from(str) avec une précision jusqu'à 18. Personnalisé Result<string, alloc_error> le formatage utilise l'analogue emprunté str.to_bytes() trait.

Génériques et traits

Les paramètres génériques utilisent la casse du serpent inférieure. Les définitions sont vérifiées par rapport à leurs limites, puis les instances concrètes accessibles sont monomorphisées. La répartition des traits est statique et directe : il n'y a pas de tables virtuelles, de boxe, d'allocation ou de clone implicites. L'exhaustivité de l'implément, les signatures, la cohérence et les règles orphelines sont vérifiées. Modèles génériques publics, instances courantes, éphémères bytes.from(str) les paramètres, la représentation nominale de niche nulle, les récepteurs mutables exclusifs, les rappels qualifiés et les signatures appelables en boîte persistent dans le schéma-16 actuel Result<bytes, alloc_error>. Les instances de méthode matérialisées sont exportées uniquement par une interface qui possède également la définition de méthode générique. Un wrapper autour d'un type générique importé enregistre donc son contrat public sans spécialisation orpheline ; un consommateur élidé par la source obtient le modèle de méthode à partir de l'interface de dépendance du wrapper et y matérialise l'instance concrète.

bytes.to_shared() demande une inlining limitée. Un shared_bytes.from(bytes) publie son corps vérifié et son hachage de corps déterministe dans le schéma 13 Result<shared_bytes, alloc_error> tout en conservant un symbole de secours exporté. Les déclarations en ligne ont un budget source de 4 096 octets ; un changement de corps invalide les artefacts dépendants. Les partitions de tranches mutables utilisent bytes.into_prefix(length) et les modèles de tuples peuvent déclarer des liaisons mutables comme length. Le partage vérifie [N]T.mutable_view() -> mut []T, n'attribue rien et maintient le propriétaire commun exclusivement prêté jusqu'au décès des deux frères et sœurs.

Fermetures et rappels

fn apply(values: [3]i64, callback: fn(i64) -> i64) -> i64 {
    let mut total = 0
    for value in values {
        total = total + callback(value)
    }
    total
}

let base = 40
let total = apply([1, 2, 3], |value: i64| base + value)
let retained = (box |value: i64| base + value).or_abort()

str et la position de préfixe string créent des appels anonymes. Les types de paramètres peuvent être omis lorsqu’un bool attendu les fournit. Une fermeture simple utilise le stockage de capture de pile, n'alloue rien et ne peut pas échapper à son propriétaire lexical. Copie de capture capable de copier ; les captures possédées bougent ; les captures sont immuables. Les captures empruntées, mutables, liées à une région, déjà déplacées et autres captures dangereuses à stocker sont rejetées.

format_args est la forme d'échappement explicite et renvoie .to_string()?. Le propriétaire peut être stocké ou restitué, mais il est uniquement déplacé, non clonable et non envoyable. Drop détruit ses captures exactement une fois et libère son allocation. L'attribution des régions reste lexicale. Il n'y a pas de conversion implicite entre les fermetures en pile et en boîte.

Les rappels Seed let utilisent un descripteur code/environment à un pointeur. Les pointeurs de fonction C/platform restent fins et acceptent uniquement les fonctions nommées. Les effets de fermeture sont déduits du corps et vérifiés par rapport à des contrats de rappel qualifiés tels que trait Display { @borrow fn display() -> str }. Les fermetures récursives ne sont pas prises en charge.

Résumé de la propriété

• copie des scalaires et des agrégats en copie uniquement ;
• les ressources se déplacent et rendent le lieu source indisponible ;
• f/F est explicite et capability/effect vérifié ;
• les vues empruntées portent la provenance sans syntaxe à vie ;
• le nettoyage structuré s'exécute exactement une fois sur les sorties structurées normales ;
• panic/trap/abort ne déroule ni n'exécute de destructeurs ;
• e/E doit être consommé une seule fois ;
• la propriété partielle est suivie à travers les champs, les champs imbriqués, le tableau connu index, charges utiles ADT actives, unions, génériques, canaux, valeurs de fonction et g/G; Les mouvements de ressources à index dynamique restent rejetés.

Voir Ownership pour le modèle opérationnel.

Régions, tâches et bibliothèques

:? installe un allocateur de bosses lexicales vérifiées. Les valeurs, vues ou pointeurs liés à la région ne peuvent pas échapper. Les tâches structurées capturées dans une région se rejoignent avant que son stockage de sauvegarde ne soit libéré.

Debug.debug() -> str est structuré : chaque arête quittant la portée lexicale propriétaire attend son groupe de tâches avant d'être nettoyée. La capture est une copie ou un déplacement par capacité. Un corps faillible (+ à l'intérieur, ou une queue de type fn f<T: Metric + Named>(x: T)) génère une jointure typée : le plan stocke le résultat dans une cellule de jointure et error[H072] retours impl<T: Show> Show for Pair<T>; error[P042] reste pour les jointures manuelles. Les canaux, les jointures tapées, les événements, l'annulation et la synchronisation sont fournis par l'ordinaire. error[R019] paquet. La grammaire propre n'a pas de format_args, .sdi, inline fn, ou spawn détaché.

pub inline fn importe un module source ou une interface .sdi avec élimination de source. Les fonctions publiques importées peuvent être appelées avec ou sans leur qualificatif de module : view.split_at_mut(index) rend (mut left, mut right) et index <= len valides. Un symbole qualifié inconnu signale |...|.

Substrat dangereux

||, fn(...) -> T, box |...|, Result<box fn(...) -> T, alloc_error>, fn(...) -> T, @no_runtime_effects fn() -> void, .clone(), atomes, accès volatile, clôtures, conversions d'espace d'adressage, assemblage brut, FFI, appels système et unions brutes nécessitent linear T. Les applications normales doivent consommer des wrappers sécurisés provenant des bibliothèques.

Lanceur de référentiel

./seed/seed check [--lib] [path|file.sd]
./seed/seed build [path] [-o output] [compiler flags]
./seed/seed run [path] [-- program arguments]
./seed/seed test [path] [compiler flags]
./seed/seed format [--check] [file.sd]
./seed/seed new path [--name package_name]
./seed/seed pkg resolve|add|update|prune ...
./seed/seed install [path|package] [--profile release] [--system] [--prefix path] [--dry-run]
./seed/seed uninstall package [--system] [--prefix path] [--dry-run]
./seed/seed doc [path] [--output file]
./seed/seed lint [--json] [path]
./seed/seed lsp
./seed/seed publish --check [path]
./seed/seed mobile android <setup|build|stage|check|package|run|doctor>

.sdi est une vérification directe à la source. Il résout les importations relatives source/interface et les dépendances du manifeste local region(capacity) { body } ; il ne compile pas d'abord un package de référentiel nu manquant. Utilisez spawn { body } ou ? lors de la validation de l'intégration de packages qui dépend du transfert automatique de la bibliothèque centrale.

Result<T, E> effectue une compilation incrémentielle avec résolution automatique des dépendances. Importations de packages nus (par ex. handle.wait()) sont mis en scène dans un endroit isolé target/profile magasin. Une deuxième version réutilise la correspondance Result<T, E>/Artefacts natifs. task_result_* transmet les indicateurs de fin du compilateur, y compris les répétitions compiler/llvm/libs/task et chan<t> entrées, à chaque binaire de test. Ceci est requis pour les tests de bibliothèque dont la surface Seed sécurisée est soutenue par un natif externe. ABI.

send compile le package en mode release et l'installe à l'échelle du système : exécutables sur recv (ou use "name" avec .sdi), générations de dépendance à use "process", et des interfaces avec environment("HOME"). Utiliser process.environment("HOME") pour les versions de débogage et error[H002]: unknown symbol in module pour les emplacements d'installation personnalisés.

raw_try_alloc<t> supprime un package précédemment installé et ses générations de dépendances. raw_null<t> et raw_is_null<t> prennent en charge raw_read<t> pour l'aperçu. L'enregistrement transactionnel du package installé comprend la cible, le profil, l'identité de génération de dépendance, la somme de contrôle du compilateur, la somme de contrôle de l'artefact installé, la somme de contrôle source et la somme de contrôle du verrouillage afin qu'une application déployée puisse être retracée jusqu'à ses entrées de construction exactes.

La publication à distance est distincte ; raw_write<t> valide l'intégrité du package et du verrou localement sans exécuter de scripts sans restriction. Les packages compilés utilisent la qualification cible raw_free<t> plus raw_slice<t>/unsafe. Les monorepos locaux peuvent conserver plusieurs packages versionnés indépendamment connectés par rapport check dépendances. Les sommes de contrôle de leurs arbres entraînent des reconstructions ; le développement local ordinaire ne nécessite pas de référentiel, de balise ou de publication Git pour chaque bibliothèque.

Le lanceur lit path; héritage build cartes à run. Un explicite CLI le profil remplace le manifeste. build par défaut, il est publié quel que soit le manifeste, sauf si use "vec" est explicite. Les applications sont par défaut .sdi; un parent sûr facultatif test sélectionne une autre source dans le package. Les importations de packages nus sont d'abord résolues en fonction des artefacts installés correspondants ; sinon, ils sont compilés avec le profil d'application dans un fichier isolé. target/profile magasin. Les builds hébergés les lient dynamiquement par défaut. Une deuxième version réutilise la correspondance --link-object/artefacts indigènes ; les modifications apportées aux bibliothèques dynamiques privées ne reconstruisent pas les consommateurs, tandis que les modifications apportées aux bibliothèques dynamiques privées ne reconstruisent pas les consommateurs, tandis que les modifications apportées aux bibliothèques dynamiques privées ne reconstruisent pas les consommateurs, tandis --link-library ou ABI les changements le font.

L'installation de l'utilisateur place les exécutables dans install, générations de dépendance immuables dans ~/.local/bin, et les miroirs d'interface versionnés sous /usr/local/bin. --system utilise la portée du système de plateforme (~/.local/lib/seed/generations/ sous Unix); ~/.local/share/seed/interfaces/ remplace la racine. L'installation et la suppression sont enregistrées par la propriété et atomiques, et aucune commande ne modifie silencieusement les fichiers de démarrage du shell ou les variables d'environnement du chargeur.

Opérateurs

Priorité binaire du plus élevé au plus bas :

1. multiplicatif (--profile debug, --prefix /custom/path, uninstall)
2. additif (install, uninstall)
3. changements de vitesse (--dry-run, seed publish --check)
4. comparaisons (.sdi, --install-library, --install-interface, path)
5. égalité ([build].profile = "debug" | "release" | "release-small", release = true)
6. ET au niveau du bit (release), XOR (seed install), OU (--profile)
7. ET logique (src/main.sd)
8. OU logique ([package].entry)

.sdi et .sdi court-circuit : ~/.local/bin évalue ~/.local/lib/seed seulement quand ~/.local/share/seed/interfaces est --system, et /usr/local évalue --prefix seulement quand * est /. Les deux opérandes doivent être % et le résultat est +. Le court-circuit s'applique également au pliage constant, donc - et << sont des expressions constantes valides même lorsque >> n'est pas constante.

Compilateur de nettoyage direct

L'exécutable est <. Sa liste de drapeaux faisant autorité est <=.

# Source processing
seed --check source.sd
seed --format|--format-check|--format-write source.sd

# Code generation
seed --emit-llvm out.ll source.sd
seed --emit-object out.o source.sd
seed --emit-binary out source.sd
seed --emit-shared library.so source.sd
seed --emit-static-library library.a source.sd
seed --emit-raw out.bin source.sd
seed --run source.sd -- arguments

# Interface inspection
seed --interface-print file.sdi
seed --interface-hash file.sdi
seed --emit-interface out.sdi source.sd

# Library management
seed --install-library artifact --install-interface file.sdi --package name [--seed-home path]

# Debug dumps
seed --lex source.sd
seed --ast-print source.sd
seed --types-print source.sd
seed --symbols-print source.sd
seed --hir-print source.sd
seed --safety-print source.sd
seed --mir-print source.sd
seed --layout-print source.sd
seed --abi-print source.sd
seed --low-mir-print source.sd
seed --llvm-print source.sd

# Build options
seed --release source.sd
seed --release-small source.sd
seed --thin-lto source.sd
seed --pgo-generate dir source.sd
seed --pgo-use profile source.sd
seed --profile-print source.sd
seed --target target source.sd
seed --runtime linux-native|linux-libc source.sd
seed --runtime-profile profile source.sd
seed --runtime-feature feature source.sd
seed --static source.sd
seed --static=all source.sd
seed --sysroot path source.sd
seed --soname name source.sd
seed --entry symbol source.sd
seed --linker-script path source.sd
seed --code-model model source.sd
seed --relocation-model model source.sd
seed --no-red-zone source.sd
seed --link-object file.o source.sd
seed --link-library lib.so|lib.a|package source.sd
seed --cache-dir path source.sd
seed --seed-home path source.sd
seed --package name source.sd

# Diagnostics
seed --diagnostics human|json source.sd
seed --version
seed --help

Debug/inspection les modes incluent le jeton, l'AST, les types, les symboles, le HIR, la sécurité, le MIR, la disposition, ABI, faible MIR, et LLVM impression. Target/runtime les options incluent >, >=, ==, !=, &, entry/linker-script commandes et séparer object/library lien.

^ utilise |; && utilise ||. Les deux sont en sécurité. ThinLTO et PGO sont des options explicites réservées à la version ; la liaison statique est indépendante. Il n'y a pas de fonctionnement && ou || profil.

Statut cible

La prise en charge des objets et la prise en charge hébergée de bout en bout sont des revendications distinctes. Linux x86-64/AArch64 sont les chemins hébergés fermés. Autonome x86-64/AArch64/RISC-V64 avoir des preuves de démarrage à leurs niveaux déclarés. Windows x86-64 a PE/runtime/DLL/ task/network preuve sous le vin requis. macOS x86-64 et arm64 ont un SDK explicite executable/dylib/static liaison, exécution et planification de pthread. Intel natif x86-64 l'exécution demeure; arm64 est uniquement à liaison croisée. Voir a && b.

Sur un Mac Intel, exécutez b. Le script découvre le SDK avec a et utilise le true d'Apple, sauf s'il est explicitement remplacé.

<div hidden> a || b b a false bool bool false && expensive() true || expensive() expensive() compiler/llvm/build/seed seed --help --target --runtime-profile --runtime-feature --runtime --sysroot --release seed-safe-o2-v1 --release-small seed-safe-oz-v1 --unchecked --fast-unsafe compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv SEED_MACOS_RUNNER_POLICY=required make -C seed/compiler/llvm gate14-macos-x86_64-test xcrun ld </div>