| /* | |
| * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| * | |
| */ | |
| #ifndef SHARE_CDS_AOTCLASSLINKER_HPP | |
| #define SHARE_CDS_AOTCLASSLINKER_HPP | |
| #include "interpreter/bytecodes.hpp" | |
| #include "memory/allocation.hpp" | |
| #include "memory/allStatic.hpp" | |
| #include "oops/oopsHierarchy.hpp" | |
| #include "utilities/exceptions.hpp" | |
| #include "utilities/growableArray.hpp" | |
| #include "utilities/macros.hpp" | |
| #include "utilities/resourceHash.hpp" | |
| class AOTLinkedClassTable; | |
| class InstanceKlass; | |
| class SerializeClosure; | |
| template <typename T> class Array; | |
| enum class AOTLinkedClassCategory : int; | |
| // AOTClassLinker is used during the AOTCache Assembly Phase. | |
| // It links eligible classes before they are written into the AOTCache | |
| // | |
| // The classes linked by AOTClassLinker are recorded in an AOTLinkedClassTable, | |
| // which is also written into the AOTCache. | |
| // | |
| // AOTClassLinker is enabled by the -XX:+AOTClassLinking option. If this option | |
| // is disabled, an empty AOTLinkedClassTable will be included in the AOTCache. | |
| // | |
| // For each class C in the AOTLinkedClassTable, the following properties for C | |
| // are assigned by AOTClassLinker and cannot be changed thereafter. | |
| // - The CodeSource for C | |
| // - The bytecodes in C | |
| // - The supertypes of C | |
| // - The ClassLoader, Package and Module of C | |
| // - The visibility of C | |
| // | |
| // During a production run, the JVM can use an AOTCache with an AOTLinkedClassTable | |
| // only if it's guaranteed to produce the same results for the above set of properties | |
| // for each class C in the AOTLinkedClassTable. | |
| // | |
| // For example, | |
| // - C may be loaded from a different CodeSource when the CLASSPATH is changed. | |
| // - Some JVMTI agent may allow the bytecodes of C to be modified. | |
| // - C may be made invisible by module options such as --add-modules | |
| // In such situations, the JVM will refuse to load the AOTCache. | |
| // | |
| class AOTClassLinker : AllStatic { | |
| static const int TABLE_SIZE = 15889; // prime number | |
| using ClassesTable = ResourceHashtable<InstanceKlass*, bool, TABLE_SIZE, AnyObj::C_HEAP, mtClassShared>; | |
| // Classes loaded inside vmClasses::resolve_all() | |
| static ClassesTable* _vm_classes; | |
| // Classes that should be automatically loaded into system dictionary at VM start-up | |
| static ClassesTable* _candidates; | |
| // Sorted list such that super types come first. | |
| static GrowableArrayCHeap<InstanceKlass*, mtClassShared>* _sorted_candidates; | |
| DEBUG_ONLY(static bool is_initialized()); | |
| static void add_vm_class(InstanceKlass* ik); | |
| static void add_new_candidate(InstanceKlass* ik); | |
| static Array<InstanceKlass*>* write_classes(oop class_loader, bool is_javabase); | |
| static int count_public_classes(oop loader); | |
| public: | |
| static void initialize(); | |
| static void add_candidates(); | |
| static void write_to_archive(); | |
| static void dispose(); | |
| // Is this class resolved as part of vmClasses::resolve_all()? | |
| static bool is_vm_class(InstanceKlass* ik); | |
| // When CDS is enabled, is ik guaranteed to be linked at deployment time (and | |
| // cannot be replaced by JVMTI, etc)? | |
| // This is a necessary (but not sufficient) condition for keeping a direct pointer | |
| // to ik in AOT-computed data (such as ConstantPool entries in archived classes, | |
| // or in AOT-compiled code). | |
| static bool is_candidate(InstanceKlass* ik); | |
| // Request that ik be added to the candidates table. This will return true only if | |
| // ik is allowed to be aot-linked. | |
| static bool try_add_candidate(InstanceKlass* ik); | |
| static int num_app_initiated_classes(); | |
| static int num_platform_initiated_classes(); | |
| // Used in logging: "boot1", "boot2", "plat", "app" and "unreg"; | |
| static const char* class_category_name(AOTLinkedClassCategory category); | |
| static const char* class_category_name(Klass* k); | |
| }; | |
| // AOT-linked classes are divided into different categories and are loaded | |
| // in two phases during the production run. | |
| enum class AOTLinkedClassCategory : int { | |
| BOOT1, // Only java.base classes are loaded in the 1st phase | |
| BOOT2, // All boot classes that not in java.base are loaded in the 2nd phase | |
| PLATFORM, // Classes for platform loader, loaded in the 2nd phase | |
| APP, // Classes for the app loader, loaded in the 2nd phase | |
| UNREGISTERED // classes loaded outside of the boot/platform/app loaders; currently not supported by AOTClassLinker | |
| }; | |
| #endif // SHARE_CDS_AOTCLASSLINKER_HPP |