Release Notes
Oracle GraalVM Enterprise Edition 19.3.6
(2021-04-20)
Oracle GraalVM Enterprise Edition 19.3.6 is a Critical Patch Update (CPU) release. This release contains fixes to security vulnerabilities announced in the April 2021 Oracle Critical Patch Update Advisory. It includes all the Oracle Java Development Kit (JDK) security fixes released as part of that CPU.
It also includes the following:
- update to 8u291 for Java 8 based GraalVM Enterprise, please see Java SE 8 release notes
- update to 11.0.11 for Java 11 based GraalVM Enterprise, please see Java SE 11 release notes
- Node.js runtime update to 12.22.1 which contains all security fixes mentioned in April 2021 Security Releases
Oracle GraalVM Enterprise Edition 19.3.5
(2021-01-19)
Oracle GraalVM Enterprise Edition 19.3.5 is a Critical Patch Update (CPU) release. This release of Oracle GraalVM Enterprise Edition fixes vulnerabilities mentioned in January 2021 Oracle Critical Patch Update Advisory. It includes all the Oracle Java Development Kit (JDK) security fixes released as part of that CPU.
It also includes the following:
- Update to Oracle JDK version 1.8.0_281 for Java 8 based GraalVM Enterprise, please see Java SE 8 release notes
- Update to Oracle JDK version 11.0.10 for Java 11 based GraalVM Enterprise, please see Java SE 11 release notes
Oracle GraalVM Enterprise Edition 19.3.4
(2020-10-20)
Oracle GraalVM Enterprise Edition 19.3.4 is a Critical Patch Update (CPU) release. This release of Oracle GraalVM Enterprise Edition fixes vulnerabilities mentioned in October 2020 Oracle Critical Patch Update Advisory. It includes all the Oracle Java Development Kit (JDK) security fixes released as part of that CPU.
It also includes the following:
- Update Java to 8u271 for Java 8 based GraalVM Enterprise, please see Java SE 8 release notes
- Update Java to 11.0.9 for Java 11 based GraalVM Enterprise, please see Java SE 11 release notes
Oracle GraalVM Enterprise Edition 19.3.3
(2020-07-14)
Oracle GraalVM Enterprise Edition 19.3.3 is a Critical Patch Update (CPU) release. It includes all the Oracle Java Development Kit (JDK) security fixes released as part of that CPU. This release fixes vulnerabilities mentioned in July 2020 Oracle Critical Patch Update Advisory.
It also includes the following:
- Update Java to 8u261 for Oracle JDK 8 based GraalVM Enterprise, please see Java SE 8 release notes
- Update Java to 11.0.8 for Oracle JDK 11 based GraalVM Enterprise, please see Java SE 11 release notes
Oracle GraalVM Enterprise Edition 19.3.2
(2020-04-14)
This is a Critical Patch Update (CPU) for Oracle GraalVM Enterprise Edition 19.3.1. The update is to address security vulnerabilities announced in the April 2020 Oracle Critical Patch Update Advisory.
The release also includes:
- Java update to 8u251 for Oracle JDK 8 based GraalVM, please see Java SE 8 release notes
- Java update to 11.0.7 for Oracle JDK 11 based GraalVM, please see Java SE 11 release notes For more details, refer to the My Oracle Support Note summarizing the changes required for Oracle GraalVM Enterprise Edition to approach this Critical Patch Update.
Oracle GraalVM Enterprise Edition 19.3.1
(2019-01-14)
This is a Critical Patch Update (CPU) for Oracle GraalVM Enterprise Edition. It contains fixes to security vulnerabilities, critical bugs, and other fixes as identified in the January 2020 Oracle Critical Patch Update Advisory.
The 19.3.1 version also includes the following:
- Update Java to 8u241 for Oracle JDK 8 based GraalVM, please see Java SE 8 Release notes.
- Update Java to 11.0.6 for Oracle JDK 11 based GraalVM, please see Java SE 11 Release notes.
- Update Ruby to 2.6.5, please see Ruby 2.6.5 release notes.
- Update Node.js to 12.14.0, please see Node.js 12.14.0 release notes.
For more information about Oracle Critical Patch Updates and Security Alerts, please visit the announcements list.
Please note that for GraalVM Enterprise Edition on Java 11, java -version
incorrectly reports a
version based on 11.0.6+1
where as it is actually 11.0.6+8
. This issue in
the GraalVM build process will be remedied in future releases.
Oracle GraalVM Enterprise Edition 19.3.0.2
(2019-12-24)
This is a bugfix update including fixes to the JVM Compiler Interface (JVMCI) and necessary updates to the JDK 11 support. The following issues were addressed:
- Approached the issue of
DynamicProxySupport
being not thread safe whenDynamicProxySupport.addProxyClass
is called from multiple threads (see #1927). - Resolved a problem leading to a wrong execution of the code produced with the GraalVM
native-image
builder at optimization level 2-H:Optimize=2
(see #1995). - Fixed a problem when JavaFX applications misbehave with
GraalArithmeticStubs
(see #1867). - Resolved an issue of VM crashing when run with Serial GC (see #1892).
ReduceInitialCardMarks
is unsafe withOptBulkAllocation
in JDK 11 (see #1915).- Fixed a transient crash while building native images with GraalVM based on JDK11 (see #1906).
Oracle GraalVM Enterprise Edition 19.3.0
(2019-11-19)
GraalVM Enterprise 19.3.0 is the first planned long-term support (LTS) release built from the main line of the project. This is also a major feature release and it is a recommended upgrade. It will continue to receive stability, security, and select performance fixes until the next LTS release is available. The LTS designation should provide a level of stability for developers to work with.
GraalVM JDK 11 Based Builds
New in the 19.3 release is the distribution of GraalVM Enterprise builds based on Oracle Java 11.0.5. GraalVM Enterprise on JDK 11 includes all the JDK changes since JDK 8. These are detailed in the release notes for JDK 9, JDK 10 and JDK 11. In particular, the Java Platform Module System (JPMS) introduced in JDK 9 means GraalVM now uses module encapsulation to isolate code such as JVMCI, the GraalVM compiler and the Truffle API from application code.
In terms of languages, GraalVM Enterprise on JDK11 supports all JVM languages (Java, Scala etc.) as well as all guest languages currently supported in GraalVM Enterprise on JDK 8. Due to the modular structure of the base JDK, there is no more $GRAALVM_HOME/jre/ directory in the GraalVM package based on JDK 11. This has an impact on the path to the languages location, e.g., $GRAALVM_HOME/jre/languages/js now becomes $GRAALVM_HOME/languages/js).
Native Image of GraalVM Enterprise functionality now also supports Java 11 code as an early adopter technology feature. Currently the native
image builder ($GRAALVM_HOME/bin/native-image
) does not support the Java Platform Module System (JPMS) and has no module introspection at image run time.
Pease note, at present GraalVM Updater cannot rebuild images ($GRAALVM_HOME/bin/gu rebuild-images
) with GraalVM Enterprise and Community editions on JDK 11. Even if GraalVM Native Image is installed, a user will encounter the following error while rebuilding:
$ $GRAALVM_HOME/bin/gu rebuild-images ruby
Error: rebuild-images utility is not available. You may need to install "native-image" component.
Please refer to documentation for the details.
A possible workaround is to rebuild images invoking rebuild-images
command directly, e.g.:
$GRAALVM_HOME/bin/rebuild-images ruby
Native Image
GraalVM Enterprise 19.3.0 switched to using the JDK native code instead of manual
substitutions. The switch to Java Native Interface
(JNI) platform enabled the possibility to provide support for JDK 11 and
extended support for Windows platforms. It has no impact on startup time or memory
footprint, and eliminates the need for shipping JDK libraries such as
libsunec.so
along with native images that use Java crypto services. GraalVM
now ships with statically linkable version of the JDK libraries.
Note that the sunec
native library of SunEC provider gets statically
linked into an image if required (see
#951). Thus native images do not
depend on the sunec
shared library anymore at runtime.
GraalVM Compiler
System.arraycopy
was improved to eliminate store checks when copying toObject[]
. That improvement fixed slowdowns (versus C2) on some Eclipse Collections benchmarks.- A performance regression when creating List values in Scala has been fixed by more optimized inlining.
- An issue that could prevent a method from being compiled that contains the JSR bytecode produced by older
javac
versions (see #1699) was resolved.
JavaScript
The Node.js runtime available with GraalVM was updated to the 12.10.0 version, which brought some breaking changes.
Additional proposals for ECMAScript 2020 have been implemented (Promise.allSettled
and Nullish coalescing) and are available in ECMAScript 2020 mode (--js.ecmascript-version=2020
).
To provide better compatibility with the ECMAScript specification, some
extensions are now disabled by default, some depending on the launcher (js
,
node
, or via GraalVM Polyglot Context). This includes the print
and
printErr
functions (the js.print
flag), the global
built-in (superseded by
globalThis
, use the js.global-property
flag to reenable), or the
performance
global property (the js.performance
flag).
More details can be found in the project changelog on GitHub.
LLVM Interpreter
In GraalVM 19.3 clang and other LLVM tools are no longer required to be installed for building the GraalVM LLVM runtime. The LLVM toolchain bundled with GraalVM Enterprise is used. The LLVM toolchain is not an “experimental” feature any more and is used by other languages.
List of features that have also been added:
- Preliminary support for parsing bitcode produced by LLVM 9
- Added intrinsics for pthread thread management functions
- Support for pthreads LLVM bitcode
Refer to the component changelog for the complete list of changes.
Python
- Python standard library were updated to 3.7.4.
- Support for NumPy 1.16.4 and Pandas 0.25.0 has been added and can be installed with:
$ graalpython -m ginstall install numpy
$ graalpython -m ginstall install pandas
- Support for basic sockets has been added. Note that SSL is not implemented, thus there is no
https
yet:
import urllib.request
print(urllib.request.urlopen("http://google.com").read())
To see a complete list of changes, please refer to the project changelog.
R
- FastR has been updated to R version 3.6.1.
- In this release, FastR does not ship with GCC runtime libraries. Use the following commands to install the necessary dependencies:
- Ubuntu 18.04 and 19.04:
apt-get install libgfortran3 libgomp1
- Oracle Linux 7:
yum install libgfortran libgomp
- Oracle Linux 8:
yum install compat-libgfortran-48
- MacOS:
brew install gcc@4.9
- Ubuntu 18.04 and 19.04:
- Preview of support for LLVM based execution of R native extensions.
- FastR is configured to use the GraalVM LLVM toolchain to compile the C/C++ and Fortran code of R packages. The resulting binaries will contain both the native code and the LLVM bitcode. The R packages that are shipped with FastR were also compiled using the GraalVM LLVM toolchain and their binaries contain the LLVM bitcode.
- FastR loads and runs the R extensions native code by default, but when run with the option
--R.BackEnd=llvm
, it will load and run the LLVM bitcode if available. You can use the LLVM backend selectively for specific R packages via--R.BackEndLLVM=pkg1,pkg2
. - A user can switch back from the GraalVM LLVM toolchain
to the native toolchain by running
fastr.setToolchain("native")
or by manually editing the$FASTR_HOME/etc/Makeconf
file.
- Fixed memory leaks reported on GitHub.
- Fixed failures when working with large vectors (>1GB).
To see the complete list of changes, please refer to the project changelog.
Ruby
A comprehensive list of changes to the Ruby language component is available on here.
The focus has been on improving compatibility with Ruby on Rails applications. Major changes include:
- Compilation of C extensions is now done with an internal LLVM toolchain producing both native code and bitcode. This means more C extensions should compile out of the box and this should resolve most linker-related issues.
- It is no longer necessary to install LLVM for installing C extensions on TruffleRuby.
- It is no longer necessary to install libc++ and libc++abi for installing C++ extensions on TruffleRuby.
- On macOS, it is no longer necessary to install the system headers package (#1417).
- License updated to EPL 2.0/GPL 2.0/LGPL 2.1 like recent JRuby.
- Installing
sassc
now works due to using the LLVM toolchain (#1753). - Include executables of default gems, needed for
rails new
in Rails 6.
Tools
Code Coverage Command Line Tool
As of version 19.3 GraalVM Enterprise provides a code coverage command line tool to record
and analyze the source code coverage of a particular execution of code for
languages implemented with the Truffle framework. Enable it with --codecoverage
option, for example js --codecoverage
. Visit the tool reference documentation for more information.
GraalVM VisualVM
- Previously, to view the JFR files a user had to install a plugin. Now GraalVM VisualVM contains the viewer in the tool core. Other JFR viewer improvements include new views for Exceptions and GC, improved performance and accuracy.
- The tool is now able to monitor and profile AArch64 Java and Java 13 processes.
Debugger
- Support for functional breakpoints and memory tools in Chrome Inspector was enabled.
Visual Studio Code Extensions
VSCode extensions are provided as VSIX packages. GraalVM team created the first
VSIX extension based on Python implementation. The extension installs with npm
package manager and upon the extension installation, the user is requested to
point the PATH environment variable to GraalVM home directory.
- The evaluation of GraalVM Language Server Protocol in VSCode has been implemented.
- VSCode now supports also GraalVM Python development.
Changes for GraalVM Embedders (SDK)
- The default temporary directory can now be configured by
FileSystem
. AgetTempDirectory()
method of theFileSystem
interface will return the default temporary directory. - The
org.graalvm.home.Version
version utility that allows to create, validate and compare GraalVM versions was added. - Added support for detecting and mapping polyglot exception values was added. Exceptions can be detected using
Value.isException()
. - The default target type mapping from guest language exceptions to
PolyglotException
was implemented.
Proceed to the SDK changelog for the complete list of changes.
Changes for GraalVM Language or Tool Implementers (Truffle)
- A standard block node for language implementations was added. The block node usage allows the optimizing
runtime to group elements of a block into multiple block compilation units. This optimization may be
enabled using
--engine.PartialBlockCompilation
(on by default) and configured using--engine.PartialBlockCompilationSize
(default 3000). - Support for boolean literals in Truffle DSL expressions was enabled. Use
true
orfalse
in expressions, e.g.isFunction(value) == false
. - Threads created by the embedder may now be collected by the GC before they can
be disposed. If languages hold onto thread objects exposed via
initializeThread
they now need to do so withWeakReference
. This avoids leaking thread instances. - A new execute method to
LoopNode
, which allows loops to return values was implemented.
To see the full list of changes to the APIs, proceed to the Truffle changelog.
Oracle GraalVM Enterprise Edition 19.2.1
(2019-10-15)
This is a Critical Patch Update (CPU) for Oracle GraalVM Enterprise Edition following a regular Oracle Java CPU schedule. The update is to address security vulnerabilities announced in the October 2019 Oracle Critical Patch Update Advisory. The 19.2.1 version is a full distribution and it is recommended to upgrade to it from older GraalVM versions.
Oracle GraalVM Enterprise Edition 19.2.1 includes all the Java security fixes released as part of that CPU and mentioned in the Java SE 8 Release notes. It also includes the following:
- update Java to 8u231
- update Node.js to 10.16.3
Listed below are critical bug fixes that went into this version:
- Fixed a problem that prevented creating a native image including the GraalVM JavaScript engine combined with
java.lang.CharSequence
implementations that have non-trivial implementations of thelength
andcharAt
methods (see #1625). - Fixed a problem that could allow an exception to propagate past a
catch
clause that should handle it.
Oracle Cloud Infrastructure customers can install GraalVM Enterprise Critical Patch Update using yum
– a package-management utility for the Linux operating systems. For more details, proceed to GraalVM on OCI page.
Oracle GraalVM Enterprise Edition 19.2.0.1
(2019-09-13)
This is a high severity update for GraalVM to address the following issues:
- Fixed a critical compiler bug that caused
String.indexOf
to be executed incorrectly on older machines that do not support theTZCNT
instruction. The problem causes incorrect string operations and typically shows up as truncated string values. - Fixed a bug causing the bounds check in Native Image’s implementation of
System.arraycopy
to overflow with large indices which typically causes process termination. - Fixed a bounds check for
System.arraycopy
in cases where the array is “virtualized” (i.e., can be in registers and stack slots instead of on the heap). - Removed declaration of otherwise unused SIOCGSTAMP symbol in Native Image. This allows use of Native Image on any Linux distribution using a 5.2.x kernel such as the latest versions of Fedora, Ubuntu (except LTS release users), Arch, openSUSE (tumbleweed).
Oracle GraalVM Enterprise Edition 19.2.0
(2019-08-20)
This is a GraalVM feature release, Oracle recommends upgrading to it from the 19.1.x or older releases.
Native Image
The process of collecting data for profile-guided optimizations (PGO) for GraalVM Enterprise native images was simplified. PGO allows to optimize performance of native images by analyzing collected profiles during the image generation process. Since 19.2.0 you can collect data for PGO while running your application in a just-in-time (JIT) compiled mode:
$ /graal-ee-19.2.0/bin/java -Dgraal.PGOInstrument=myclass.iprof MyClass
$ /graal-ee-19.2.0/bin/native-image --pgo=myclass.iprof MyClass
$ ./myclass
Performance
There has been a throughput improvement for Native Image in GraalVM Enterprise when no profiles are available. Running the Micronaut GraalVM example shows spending ~10% less CPU time and achieving a ~10% higher throughput of requests per CPU second in 19.2.0.
A common usability problem was solved when a class marked for
initialization at runtime gets inadvertently initialized at build time. The flag -H:+TraceClassInitialization
was introduced to help tracing what classes got initialized at runtime.
JavaScript
- Added support for date, time, timezone, instant and duration interoperability types to distinguish date-like objects from multiple languages in polyglot contexts (see changes to GraalVM SDK and Truffle APIs).
- Added
Context.Builder.timeZone
to set the time zone. - Implemented the Numeric separators TC39 proposal. It is
available in ECMAScript 2020 mode (
--js.ecmascript-version=2020
). - Moved ICU data for internationalization APIs, e.g. date and time formatting, number formatting, collation for each individual supported language, previously distributed as separate files in
<GRAALVM_HOME>/jre/languages/js/icu4j/icudt
to the executable of JavaScript (js
).
More changes are listed in the JavaScript component changelog.
LLVM Interpreter
A preliminary support for compiling native programs to bitcode using the LLVM toolchain was introduced. The LLVM toolchain is a set of tools and APIs for compiling native projects, such as C and C++, to bitcode that can be executed with the GraalVM LLVM runtime. It is aimed to simplify ahead-of-time compilation for users and language implementers who want to use the GraalVM LLVM runtime. To do so, the launchers that invoke the C/C++ compiler with special flags are provided to produce results that can be executed by the GraalVM LLVM runtime. For more details, please consult the LLVM reference documentation.
The toolchain is an experimental feature in this release. A complete list of changes to GraalVM LLVM runtime can be found in the changelog.
Ruby
A comprehensive list of changes to Ruby language component is available on GitHub. Major changes include:
- Implemented support for Fiddle – an extension to translate a foreign function interface (FFI) and libffi wrapper for Ruby.
- In terms of compatibility,
Thread.report_on_exception
is nowtrue
by default like MRI 2.5+;BigDecimal
compatibility has been generally improved in several ways. - Improved the performance by optimizing
String
methods to use the vector instructions when searching for a single-byte character in aString
. - Fixed several bugs:
R
- Added a new
fastRCluster
package that allows to run FastR inside GNU-R:- install in GNU-R or RStudio with:
devtools::install_github('oracle/fastr/com.oracle.truffle.r.pkgs/fastRCluster')
; - use
?fastRCluster
to learn more.
- install in GNU-R or RStudio with:
- The problem that
SET_ATTRIB
does not validate the attributes as expected was resolved.
The changelog is available on GitHub.
Python
The GraalVM Python implementation is still experimental and we are working towards improving completeness.
- Implemented
PyStructSequence_*
C API – standard structured prediction functions. - Added support for more C API functions as
PyEval_InitThreads
andPyEval_ThreadsInitialized
, type attributes i.e.nb_remainder
,nb_subtract
,overflowed
andrecursion_depth
thread state fields. - Fixed printing of errors in the REPL and full paths in tracebacks.
More details are available in the project changelog on GitHub.
API Changes for GraalVM Integrators (SDK + Truffle)
The ability to configure custom polyglot access with
PolyglotAccess.newBuilder()
has been implemented. It allows to configure fine-grained access
control for polyglot bindings and between polyglot languages. For example, given
a TruffleObject
as a value, there is a need to determine language and type of
that object. This feature is significant for GraalVM execution inside Oracle RDBMS.
GraalVM 19.1.1 release also added support for date, time, timezone, duration
values in polyglot APIs, and introduced the Context.Builder.timeZone(ZoneId)
class to configure the default timezone of polyglot contexts.
The major GraalVM SDK and Truffle APIs changes between the versions are summarized in:
Tools
A preview version of Java Flight Recorder (JFR) support has been released as a plugin for the VisualVM tool bundled with GraalVM 19.1.1. The plugin reads all JFR snapshots created from Java 7 and newer and presents the data in typical VisualVM views familiar for its users.
To install the JFR support, download GraalVM 19.2.0, unzip it and run
JFR support is currently an experimental feature. Some advanced features like analyzing JVM internals, showing event stack traces or support for creating JFR snapshots from live processes are not available in the preview version and will be addressed incrementally in the following releases.
GraalVM Updater Utility
The issue where GraalVM Enterprise would by default download the GraalVM Community components from GitHub was fixed. For a GraalVM Community user – nothing changes, you can still install the components as before, and the gu
will locate the necessary jar files on GitHub and correctly install them:
gu install native-image ruby R python
For GraalVM Enterprise, install R and llvm-toolchain components from GitHub, for example:
gu install R
The other components are available from the OTN page, and can be installed from a manually downloaded file, for example to install native-image
support run:
gu install -L native-image-installable-svm-svmee-darwin-amd64-19.2.0.jar
Version Calendar
You can now refer to GraalVM version calendar to learn more about the GraalVM release model and prepare for upcoming releases.
Oracle GraalVM Enterprise Edition 19.1.1
(2019-07-16)
This is a Critical Patch Update (CPU) release for the 19.1.0 GraalVM release. Oracle recommends upgrading to it from the 19.1.x and older releases.
This CPU release has been induced by the update to OracleJDK from 8u212 to 8u221 as the base JDK of GraalVM Enterprise. More details can be found here and here.
This CPU release includes fixes for the following CVEs:
- CVE-2019-2813
- CVE-2019-2862
For more information please see the Oracle July 2019 Security Advisory.
Critical fixes to GraalVM Native Image listed below went also into this version:
-
Fixed
Reflection.getCallerClass
methods sometimes failing to acquire the correct frame in the native images (#1479). -
Fixed an issue that could cause header files not being generated in the working directory when compiling shared libraries ahead-of-time.
Oracle GraalVM Enterprise Edition 19.1.0
(2019-07-02)
This is a feature release. It is recommend upgrading to it from the 19.0.x releases.
Java
- Improved speed of just-in-time (JIT) compilation in GraalVM, which significantly improves the performance on medium length workloads.
- Applied profile-guided optimization (PGO) when building the ahead-of-time (AOT) image of the compiler. This enables more aggressive optimization of the compiler itself providing better compilation throughput.
Native Image
We fixed many issues that were reported on GitHub. You can browse the full list here.
JavaScript
- Allow making evaluated sources internal using the
sourceURL
directive by prefixing the URL withinternal:
, e.g.//# sourceURL=internal:myname.js
. - Improved code sharing across threads. Prior to this one context had to be closed before the code in it could be reused in another context, now for JavaScript contexts one can share code using
ContextPolicy.SHARED
without closing the context. In the following example thesource
code is shared betweencontext1
andcontext2
:
public static void main(String[] args) {
try (Engine engine = Engine.create()) {
Source source = Source.create("js", "21 + 21");
try (
Context context1 = Context.newBuilder().engine(engine).build();
Context context2 = Context.newBuilder().engine(engine).build()) {
context1.eval(source).asInt();
context2.eval(source).asInt();
}
}
}
LLVM Interpreter
- Calling
exit(...)
in an embedded context is now a catchablePolyglotException
. - Skip source path entries that we are not allowed to access. Previously, when running in an embedded context with restricted access to the file system, the LLVM engine threw an exception when it could not read the source files, even if no debugger was attached. Now it will still run. Only when a debugger is attached, an error is reported when the source file cannot be accessed.
Ruby
The GraalVM Ruby implementation in this version targets performance and compatibility improvements, new features implementations and multiple bug fixes. The most notable include:
- Interactive sources (like the GraalVM polyglot shell) now all share the same binding (#1695).
- Hash code calculation has been improved to reduce hash collisions for
Hash
and other cases. eval(code, binding)
for a fixed code containing blocks is now much faster. This improves the performance of rendering ERB templates containing loops.rb_str_cat
is faster due to the C string now being concatenated without first being converted to a Ruby string or having its encoding checked.
There is Ruby component changelog available.
R
- Strings
-Inf
,+NaN
, and-NaN
are correctly parsed to doubles including ignoring leading and trailing whitespaces. - For loop creates and initializes the control variable even if there are no iterations (#77).
- Updated the output of the capabilities builtin (#78).
- Now
is.function
returns true for foreign executables.
Python
- Updated Python standard library files from 3.7.0 to 3.7.3.
- Improved performance of exceptions that do not escape.
- Fixed caching of core sources in a native image with a preinitialized context for pre-built images and libpolyglot fast startup.
- Implemented support for
pwd.getpwuid
,os.exec
,os.execv
, andos.execl
modules.
For more information, proceed to the changelog.
Oracle GraalVM Enterprise Edition 19.0.2
(2019-06-13)
This is a bug fix release for 19.0.0.
Java
- Improved compilation performance of scheduler phase.
- Support retrieving annotations from class initializers (see 1320).
- Fixed problems related to the freetype library: 1269, 1270, 1305.
- Fixed Version string reporting (it was missing
64-Bit
in the string).
Native Image
- Fixed
IllegalArgumentException: Cannot create Method for class initializer
(see 1320). - Fixed an issue when the build would loop forever if
META-INF/native-image/native-image.properties
contains--force-fallback
. - Fixed the issue where fallback image generation would not respect the
--no-server
argument. - Fix
native-image-agent=restrict
configuration detection. - Added
-agentlib:native-image-agent=build
configuration option.
LLVM Interpreter
- Allow LLVM interpreter Context to run without
allowIO(true)
.
Oracle GraalVM Enterprise Edition 19.0.0
(2019-05-09)
We are pleased to announce the first public general availability release of Oracle GraalVM Enterprise Edition 19.
GraalVM Enterprise is built on the global standard for enterprise-class application development, Java SE. GraalVM Enterprise is a multilingual virtual machine and delivers even higher efficiency, better isolation and greater agility for enterprises in cloud and hybrid environments.
The core features of GraalVM Enterprise are:
- GraalVM Compiler – compiles Java bytecode to machine code, can be used as a top-tier just-in-time (JIT) compiler in the JVM or as an ahead-of-time (AOT) compiler in the GraalVM Enterprise environment.
- Polyglot Capabilities – supports JVM languages, JavaScript, and Node.js.
- Language Implementation Framework – enables implementing programming languages for the GraalVM Enterprise environment.
- LLVM Runtime – executes native code in a managed environment.
Additional features which can be added to the GraalVM Enterprise installation include:
- GraalVM Native Image – ahead of time compilation functionality, offered as an early adopter preview.
- Polyglot, experimental support for the Python, R, and Ruby languages.
Base GraalVM Enterprise 19 distribution includes the following runtimes:
- JDK 1.8.0_212 based Java HotSpot(TM) VM
- Node.js v10.15.2
- JavaScript Engine compatible with ECMAScript 2019
- LLVM Runtime compatible with LLVM 7.0
Learn how to begin using GraalVM Enterprise in the Getting Started section of the documentation.