Native Image

Native Image kompiliert eine JVM-Anwendung vorab zu einer eigenständigen ausführbaren Datei oder einer Shared Library.

Über die Befehlszeile kompilieren

elide native-image -- -cp app.jar com.example.Main

Compiler-Argumente folgen nach --; elide native-image -- --help listet sie auf. Reflection, Ressourcen, JNI und Proxys benötigen Reachability-Metadaten. Für das abschließende Linken braucht der Host eine C-Werkzeugkette.

Projektartefakt

amends "elide:project.pkl"
import "elide:Jvm.pkl" as Jvm
import "elide:NativeImage.pkl" as Native

artifacts {
  ["app-jar"] = new Jvm.Jar {
    sources { "main" }
  }
  ["app"] = new Native.NativeImage {
    from { "app-jar" }
    entrypoint = "com.example.Main"
    type = "binary"
    options {
      optimization = "2"
      flags { "-H:+ReportExceptionStackTraces" }
    }
  }
}

Eigenschaft	Bedeutung	Standard
`from`	Schlüssel von JAR-Artefakten (keine Pfade); leer bedeutet jedes deklarierte JAR oder ein JAR mit den Klassen des Projekts.	keine
`name`	Name der Ausgabedatei.	der Projektname
`entrypoint`	Hauptklasse.	`jvm.main`
`moduleName`	Startmodul für modulare JARs; siehe unten.	das Modul mit dem Einstiegspunkt
`type`	`"binary"` (ausführbare Datei) oder `"library"` (Shared Library).	`"binary"`
`options`	Compiler-Optionen; siehe unten.	—
`dependsOn`	Artefakte, die zuerst gebaut werden.	keine

Die Ausgabe wird nach .dev/artifacts/native-image/ geschrieben, die endgültigen Argumente nach native-image.args.

Compiler-Optionen

Eigenschaft von `options`	Bedeutung	Standard
`optimization`	`"auto"`, `"b"` (schneller Build), `"s"`, `"0"` … `"4"`.	`"auto"`
`driverMode`	`"embedded"` (der Compiler von Elide) oder `"external"` (`native-image` aus `GRAALVM_HOME`/`JAVA_HOME`).	`"embedded"`
`verbose`	Ausführliche Compiler-Ausgabe.	`false`
`linkAtBuildTime.enabled`	Alles zur Build-Zeit linken.	`true`
`linkAtBuildTime.packages`	Pakete, die zur Build-Zeit gelinkt werden, wenn `enabled` `false` ist.	keine
`classInit.default`	Standard-Klasseninitialisierung: `"buildtime"` oder `"runtime"`.	`"buildtime"`
`classInit.buildtime`, `classInit.runtime`	Klassen oder Pakete, die zur Build-Zeit oder zur Laufzeit initialisiert werden.	keine
`exclusions.all`	Koordinaten, die von beiden Pfaden ferngehalten werden.	die JARs des Compilers selbst
`exclusions.classpath`, `exclusions.modulepath`	Koordinaten, die von einem der Pfade ferngehalten werden.	keine
`pgo.enabled`	Profile anwenden, sofern vorhanden.	`true`
`pgo.profiles`	Profildateien.	keine
`pgo.instrument`	Ein instrumentiertes Image bauen, das Profile aufzeichnet.	`false`
`pgo.sampling`	Sampling-Profile verwenden.	`false`
`pgo.autoprofile`	Auto-Profiling-Funktionen.	`false`
`features`	Zu aktivierende Compiler-Feature-Klassen.	keine
`flags`	Zusätzliche `native-image`-Flags; ändert sich eine in einem Flag genannte Datei, wird neu gebaut.	keine
`cflags`, `ldflags`	Zusätzliche Flags für C-Compiler und Linker.	keine
`defs`	Systemeigenschaften für den Image-Build.	keine

Der Block nativeImage { } auf oberster Ebene akzeptiert dieselben Optionen, wendet sie aber nicht an; setzen Sie die options jedes Artefakts.

Modulare Anwendungen

Wenn ein JAR in from eine module-info.class enthält:

Modulare JARs und der Bucket dependencies.maven.modules kommen mit --add-modules=ALL-MODULE-PATH auf --module-path; alles andere bleibt auf dem Classpath.
Das Binary startet mit --module <module>/<entrypoint>, wobei moduleName oder das Modul mit dem Einstiegspunkt verwendet wird.
Ein Einstiegspunkt außerhalb jedes Moduls wird über den Classpath gebaut.

moduleName hat ohne modulare JARs keine Wirkung.

Zu WebAssembly kompilieren

Deklarieren Sie ein WebImage-Artefakt oder übergeben Sie --tool:wasm-gc / --tool:wasm-lm; siehe WebImage. Zum Ausführen von vorhandenem WASM siehe WebAssembly. Ein Native Image kann die Eingabe für ein Container-Image sein.