RFR: 8367387: Add @AOTInitialize annotation [v4]

[Ashutosh Mehra]

On Tue, 16 Sep 2025 17:40:48 GMT, Ioi Lam <iklam at openjdk.org> wrote:

>> This PR adds a new annotation, `@AOTInitialize` that forces a class to be (a) initialized in the AOT assembly phase, and (b) stored in the AOT cache in an already initialized state. This means that all the static fields in this class will be immediately available upon JVM bootstrap when the AOT cache is used in an application's production run.
>> 
>> This PR annotates a single class, `jdk.internal.math.MathUtils` (also the object hierarchy root class, `Object.class`, which has no associated AOT initialization but is required for completeness). More classes will be added in future PRs.
>> 
>> If a class `K` has the `@AOTInitialize` annotation, the same annotation must be also added to
>> - All of `K`'s super classes
>> - All of `K`'s super interfaces that require to be initialized when `K` is initialized (see JVMS 5.5. Initialization, step 7; also C++ function `InstanceKlass::interface_needs_clinit_execution_as_super()`
>> 
>> Note, the check of the above requirement has been moved to `AOTClassInitializer::check_aot_annotations()`. The previous check in `ClassFileParser` was not executed because the class is loaded in the AOT training run, where `CDSConfig::is_initing_classes_at_dump_time()` returns `false` (this function returns `true` only in the AOT assembly phase).
>> 
>> This annotation is awfully similar to `@AOTSafeClassInitializer`, and I am not sure if we need both. Please see the javadoc in `@AOTInitialize` to see the difference between the two annotations.
>
> Ioi Lam has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Added logging about @AOTSafeClassInitializer classes that have not been initialized

> Note, the check of the above requirement has been moved to AOTClassInitializer::check_aot_annotations(). The previous check in ClassFileParser was not executed because the class is loaded in the AOT training run, where CDSConfig::is_initing_classes_at_dump_time() returns false (this function returns true only in the AOT assembly phase).

So this is a bug already present in the code and effectively disables super type checks for AOTSafeClassInitializer annotation, is that right?
There is a reference to ClassFileParser in the documentation for AOTSafeClassInitializer. I think it needs to be updated as well: https://github.com/openjdk/jdk/blob/18dc186a8f4820ed78c21173713dd127ef512e1f/src/java.base/share/classes/jdk/internal/vm/annotation/AOTSafeClassInitializer.java#L124-L129

src/hotspot/share/cds/aotClassInitializer.cpp line 53:

> 51: 
> 52:   if (ik->force_aot_initialization()) {
> 53:     assert(ik->is_initialized(), "must have been initialized before this check");

Is it not possible for a jdk class to be loaded but not initialized during an application run? If such a jdk class is marked with AOTInitialize annotation, this assert would trigger during the assembly phase.

-------------

PR Comment: https://git.openjdk.org/jdk/pull/27024#issuecomment-3304237468
PR Review Comment: https://git.openjdk.org/jdk/pull/27024#discussion_r2356493896