/*

 * 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.

 */

package jdk.tools.jaotc.binformat;

import static org.graalvm.compiler.hotspot.meta.HotSpotAOTProfilingPlugin.Options.TieredAOT;

import java.io.ByteArrayOutputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import jdk.tools.jaotc.binformat.Symbol.Binding;

import jdk.tools.jaotc.binformat.Symbol.Kind;

import jdk.tools.jaotc.binformat.elf.JELFRelocObject;

import jdk.tools.jaotc.binformat.macho.JMachORelocObject;

import jdk.tools.jaotc.binformat.pecoff.JPECoffRelocObject;

import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;

import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration;

import org.graalvm.compiler.options.OptionValues;

/**

 * A format-agnostic container class that holds various components of a binary.

 *

 * <p>

 * This class holds information necessary to create platform-specific binary containers such as

 * ELFContainer for Linux and Solaris operating systems or MachOContainer for Mac OS or PEContainer

 * for MS Windows operating systems.

 *

 * <p>

 * Method APIs provided by this class are used to construct and populate platform-independent

 * contents of a binary as the first step to create a binary representation of code generated by a

 * compiler backend such as Graal.

 *

 * <p>

 * Methods to record and access code section contents, symbols and relocations are provided.

 */

public final class BinaryContainer implements SymbolTable {

    private final OptionValues graalOptions;

    private final int codeSegmentSize;

    private final int codeEntryAlignment;

    private final boolean threadLocalHandshakes;

    /**

     * Container holding code bits and any other related information.

     */

    private final CodeContainer codeContainer;

    /**

     * Container holding global offset data for hotspot linkage.

     */

    private final ByteContainer extLinkageGOTContainer;

    /**

     * Patched by HotSpot, contains Klass pointers.

     */

    private final ByteContainer klassesGotContainer;

    /**

     * Patched by HotSpot, contains MethodCounters pointers.

     */

    private final ByteContainer countersGotContainer;

    /**

     * Patched lazily by hotspot, contains klass/method pointers.

     */

    private final ByteContainer metadataGotContainer;

    /**

     * BSS container, contains method state array.

     */

    private final ByteContainer methodStateContainer;

    /**

     * Patched by hotspot, contains java object pointers.

     */

    private final ByteContainer oopGotContainer;

    // Containers holding read-only data

    private final ReadOnlyDataContainer configContainer;

    private final ReadOnlyDataContainer metaspaceNamesContainer;

    private final ReadOnlyDataContainer methodsOffsetsContainer;

    private final ReadOnlyDataContainer klassesOffsetsContainer;

    private final ReadOnlyDataContainer klassesDependenciesContainer;

    private final HeaderContainer headerContainer;

    private final ReadOnlyDataContainer stubsOffsetsContainer;

    private final ReadOnlyDataContainer codeSegmentsContainer;

    // This cannot be read only since we need to patch the metadata at runtime..

    private final ReadOnlyDataContainer methodMetadataContainer;

    /**

     * Container containing constant data used by code.

     */

    private final ReadOnlyDataContainer constantDataContainer;

    /**

     * Map holding the Strings table.

     */

    private final Map<String, Integer> offsetStringTable = new HashMap<>();

    private final Map<String, Integer> metaspaceNames = new HashMap<>();

    // List of relocation table entries - (symbolName, relocationInfo)

    private final Map<String, Symbol> symbolTable = new HashMap<>();

    private final Map<Symbol, List<Relocation>> relocationTable = new HashMap<>();

    private final Map<Symbol, Relocation> uniqueRelocationTable = new HashMap<>();

    /**

     * Mapping of local VM function names to known global symbols generated in the output binary.

     */

    private static final HashMap<String, String> functionNamesToAOTSymbols = new HashMap<>();

    //@formatter:off

    private static final String[][] map = {

        {"CompilerToVM::Data::SharedRuntime_deopt_blob_unpack",         "_aot_deopt_blob_unpack"},

        {"CompilerToVM::Data::SharedRuntime_deopt_blob_uncommon_trap",  "_aot_deopt_blob_uncommon_trap"},

        {"CompilerToVM::Data::SharedRuntime_ic_miss_stub",              "_aot_ic_miss_stub"},

        {"CompilerToVM::Data::SharedRuntime_handle_wrong_method_stub",  "_aot_handle_wrong_method_stub"},

        {"SharedRuntime::exception_handler_for_return_address",         "_aot_exception_handler_for_return_address"},

        {"SharedRuntime::register_finalizer",                           "_aot_register_finalizer"},

        {"SharedRuntime::OSR_migration_end",                            "_aot_OSR_migration_end"},

        {"SharedRuntime::enable_stack_reserved_zone",                   "_aot_enable_stack_reserved_zone"},

        {"CompilerRuntime::resolve_dynamic_invoke",                     "_aot_resolve_dynamic_invoke"},

        {"CompilerRuntime::resolve_string_by_symbol",                   "_aot_resolve_string_by_symbol"},

        {"CompilerRuntime::resolve_klass_by_symbol",                    "_aot_resolve_klass_by_symbol"},

        {"CompilerRuntime::resolve_method_by_symbol_and_load_counters", "_aot_resolve_method_by_symbol_and_load_counters"},

        {"CompilerRuntime::initialize_klass_by_symbol",                 "_aot_initialize_klass_by_symbol"},

        {"CompilerRuntime::invocation_event",                           "_aot_invocation_event"},

        {"CompilerRuntime::backedge_event",                             "_aot_backedge_event"},

        {"CompilerToVM::Data::dpow", "_aot_shared_runtime_dpow"},

        {"CompilerToVM::Data::dexp", "_aot_shared_runtime_dexp"},

        {"CompilerToVM::Data::dcos", "_aot_shared_runtime_dcos"},

        {"CompilerToVM::Data::dsin", "_aot_shared_runtime_dsin"},

        {"CompilerToVM::Data::dtan", "_aot_shared_runtime_dtan"},

        {"CompilerToVM::Data::dlog", "_aot_shared_runtime_dlog"},

        {"CompilerToVM::Data::dlog10", "_aot_shared_runtime_dlog10"},

        {"StubRoutines::_jbyte_arraycopy", "_aot_stub_routines_jbyte_arraycopy"},

        {"StubRoutines::_jshort_arraycopy", "_aot_stub_routines_jshort_arraycopy"},

        {"StubRoutines::_jint_arraycopy", "_aot_stub_routines_jint_arraycopy"},

        {"StubRoutines::_jlong_arraycopy", "_aot_stub_routines_jlong_arraycopy"},

        {"StubRoutines::_oop_arraycopy", "_aot_stub_routines_oop_arraycopy"},

        {"StubRoutines::_oop_arraycopy_uninit", "_aot_stub_routines_oop_arraycopy_uninit"},

        {"StubRoutines::_jbyte_disjoint_arraycopy", "_aot_stub_routines_jbyte_disjoint_arraycopy"},

        {"StubRoutines::_jshort_disjoint_arraycopy", "_aot_stub_routines_jshort_disjoint_arraycopy"},

        {"StubRoutines::_jint_disjoint_arraycopy", "_aot_stub_routines_jint_disjoint_arraycopy"},

        {"StubRoutines::_jlong_disjoint_arraycopy", "_aot_stub_routines_jlong_disjoint_arraycopy"},

        {"StubRoutines::_oop_disjoint_arraycopy", "_aot_stub_routines_oop_disjoint_arraycopy"},

        {"StubRoutines::_oop_disjoint_arraycopy_uninit", "_aot_stub_routines_oop_disjoint_arraycopy_uninit"},

        {"StubRoutines::_arrayof_jbyte_arraycopy", "_aot_stub_routines_arrayof_jbyte_arraycopy"},

        {"StubRoutines::_arrayof_jshort_arraycopy", "_aot_stub_routines_arrayof_jshort_arraycopy"},

        {"StubRoutines::_arrayof_jint_arraycopy", "_aot_stub_routines_arrayof_jint_arraycopy"},

        {"StubRoutines::_arrayof_jlong_arraycopy", "_aot_stub_routines_arrayof_jlong_arraycopy"},

        {"StubRoutines::_arrayof_oop_arraycopy", "_aot_stub_routines_arrayof_oop_arraycopy"},

        {"StubRoutines::_arrayof_oop_arraycopy_uninit", "_aot_stub_routines_arrayof_oop_arraycopy_uninit"},

        {"StubRoutines::_arrayof_jbyte_disjoint_arraycopy", "_aot_stub_routines_arrayof_jbyte_disjoint_arraycopy"},

        {"StubRoutines::_arrayof_jshort_disjoint_arraycopy", "_aot_stub_routines_arrayof_jshort_disjoint_arraycopy"},

        {"StubRoutines::_arrayof_jint_disjoint_arraycopy", "_aot_stub_routines_arrayof_jint_disjoint_arraycopy"},

        {"StubRoutines::_arrayof_jlong_disjoint_arraycopy", "_aot_stub_routines_arrayof_jlong_disjoint_arraycopy"},

        {"StubRoutines::_arrayof_oop_disjoint_arraycopy", "_aot_stub_routines_arrayof_oop_disjoint_arraycopy"},

        {"StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit", "_aot_stub_routines_arrayof_oop_disjoint_arraycopy_uninit"},

        {"StubRoutines::_unsafe_arraycopy", "_aot_stub_routines_unsafe_arraycopy"},

        {"StubRoutines::_checkcast_arraycopy", "_aot_stub_routines_checkcast_arraycopy"},

        {"StubRoutines::_generic_arraycopy", "_aot_stub_routines_generic_arraycopy"},

        {"StubRoutines::_aescrypt_encryptBlock", "_aot_stub_routines_aescrypt_encryptBlock"},

        {"StubRoutines::_aescrypt_decryptBlock", "_aot_stub_routines_aescrypt_decryptBlock"},

        {"StubRoutines::_cipherBlockChaining_encryptAESCrypt", "_aot_stub_routines_cipherBlockChaining_encryptAESCrypt"},

        {"StubRoutines::_cipherBlockChaining_decryptAESCrypt", "_aot_stub_routines_cipherBlockChaining_decryptAESCrypt"},

        {"StubRoutines::_electronicCodeBook_encryptAESCrypt", "_aot_stub_routines_electronicCodeBook_encryptAESCrypt"},

        {"StubRoutines::_electronicCodeBook_decryptAESCrypt", "_aot_stub_routines_electronicCodeBook_decryptAESCrypt"},

        {"StubRoutines::_updateBytesCRC32", "_aot_stub_routines_update_bytes_crc32"},

        {"StubRoutines::_crc_table_adr", "_aot_stub_routines_crc_table_adr"},

        {"StubRoutines::_sha1_implCompress", "_aot_stub_routines_sha1_implCompress" },

        {"StubRoutines::_sha1_implCompressMB", "_aot_stub_routines_sha1_implCompressMB" },

        {"StubRoutines::_sha256_implCompress", "_aot_stub_routines_sha256_implCompress" },

        {"StubRoutines::_sha256_implCompressMB", "_aot_stub_routines_sha256_implCompressMB" },

        {"StubRoutines::_sha512_implCompress", "_aot_stub_routines_sha512_implCompress" },

        {"StubRoutines::_sha512_implCompressMB", "_aot_stub_routines_sha512_implCompressMB" },

        {"StubRoutines::_multiplyToLen", "_aot_stub_routines_multiplyToLen" },

        {"StubRoutines::_counterMode_AESCrypt", "_aot_stub_routines_counterMode_AESCrypt" },

        {"StubRoutines::_ghash_processBlocks", "_aot_stub_routines_ghash_processBlocks" },

        {"StubRoutines::_base64_encodeBlock", "_aot_stub_routines_base64_encodeBlock" },

        {"StubRoutines::_crc32c_table_addr", "_aot_stub_routines_crc32c_table_addr" },

        {"StubRoutines::_updateBytesCRC32C", "_aot_stub_routines_updateBytesCRC32C" },

        {"StubRoutines::_updateBytesAdler32", "_aot_stub_routines_updateBytesAdler32" },

        {"StubRoutines::_squareToLen", "_aot_stub_routines_squareToLen" },

        {"StubRoutines::_mulAdd", "_aot_stub_routines_mulAdd" },

        {"StubRoutines::_montgomeryMultiply", "_aot_stub_routines_montgomeryMultiply" },

        {"StubRoutines::_montgomerySquare", "_aot_stub_routines_montgomerySquare" },

        {"StubRoutines::_vectorizedMismatch", "_aot_stub_routines_vectorizedMismatch" },

        {"StubRoutines::_throw_delayed_StackOverflowError_entry", "_aot_stub_routines_throw_delayed_StackOverflowError_entry" },

        {"os::javaTimeMillis", "_aot_os_javaTimeMillis"},

        {"os::javaTimeNanos", "_aot_os_javaTimeNanos"},

        {"JVMCIRuntime::monitorenter", "_aot_jvmci_runtime_monitorenter"},

        {"JVMCIRuntime::monitorexit", "_aot_jvmci_runtime_monitorexit"},

        {"JVMCIRuntime::object_notify", "_aot_object_notify"},

        {"JVMCIRuntime::object_notifyAll", "_aot_object_notifyAll"},

        {"JVMCIRuntime::log_object", "_aot_jvmci_runtime_log_object"},

        {"JVMCIRuntime::log_printf", "_aot_jvmci_runtime_log_printf"},

        {"JVMCIRuntime::vm_message", "_aot_jvmci_runtime_vm_message"},

        {"JVMCIRuntime::new_instance", "_aot_jvmci_runtime_new_instance"},

        {"JVMCIRuntime::new_array", "_aot_jvmci_runtime_new_array"},

        {"JVMCIRuntime::new_multi_array", "_aot_jvmci_runtime_new_multi_array"},

        {"JVMCIRuntime::dynamic_new_instance", "_aot_jvmci_runtime_dynamic_new_instance"},

        {"JVMCIRuntime::dynamic_new_array", "_aot_jvmci_runtime_dynamic_new_array"},

        {"JVMCIRuntime::new_instance_or_null", "_aot_jvmci_runtime_new_instance_or_null"},

        {"JVMCIRuntime::new_array_or_null", "_aot_jvmci_runtime_new_array_or_null"},

        {"JVMCIRuntime::new_multi_array_or_null", "_aot_jvmci_runtime_new_multi_array_or_null"},

        {"JVMCIRuntime::dynamic_new_instance_or_null", "_aot_jvmci_runtime_dynamic_new_instance_or_null"},

        {"JVMCIRuntime::dynamic_new_array_or_null", "_aot_jvmci_runtime_dynamic_new_array_or_null"},

        {"JVMCIRuntime::log_primitive", "_aot_jvmci_runtime_log_primitive"},

        {"JVMCIRuntime::validate_object", "_aot_jvmci_runtime_validate_object"},

        {"JVMCIRuntime::write_barrier_pre", "_aot_jvmci_runtime_write_barrier_pre"},

        {"JVMCIRuntime::identity_hash_code", "_aot_jvmci_runtime_identity_hash_code"},

        {"JVMCIRuntime::write_barrier_post", "_aot_jvmci_runtime_write_barrier_post"},

        {"JVMCIRuntime::thread_is_interrupted", "_aot_jvmci_runtime_thread_is_interrupted"},

        {"JVMCIRuntime::exception_handler_for_pc", "_aot_jvmci_runtime_exception_handler_for_pc"},

        {"JVMCIRuntime::test_deoptimize_call_int", "_aot_jvmci_runtime_test_deoptimize_call_int"},

        {"JVMCIRuntime::throw_and_post_jvmti_exception",      "_aot_jvmci_runtime_throw_and_post_jvmti_exception"},

        {"JVMCIRuntime::throw_klass_external_name_exception", "_aot_jvmci_runtime_throw_klass_external_name_exception"},

        {"JVMCIRuntime::throw_class_cast_exception",          "_aot_jvmci_runtime_throw_class_cast_exception"},

        {"JVMCIRuntime::vm_error", "_aot_jvmci_runtime_vm_error"}

    };

    //@formatter:on

    static {

        for (String[] entry : map) {

            functionNamesToAOTSymbols.put(entry[0], entry[1]);

        }

    }

    /**

     * Allocates a {@code BinaryContainer} object whose content will be generated in a file with the

     * prefix {@code prefix}. It also initializes internal code container, symbol table and

     * relocation tables.

     *

     * @param graalOptions

     */

    public BinaryContainer(OptionValues graalOptions, GraalHotSpotVMConfig graalHotSpotVMConfig, GraphBuilderConfiguration graphBuilderConfig, int gc, String jvmVersion) {

        this.graalOptions = graalOptions;

        this.codeSegmentSize = graalHotSpotVMConfig.codeSegmentSize;

        if (codeSegmentSize < 1 || codeSegmentSize > 1024) {

            throw new InternalError("codeSegmentSize is not in range [1, 1024] bytes: (" + codeSegmentSize + "), update JPECoffRelocObject");

        }

        if ((codeSegmentSize & (codeSegmentSize - 1)) != 0) {

            throw new InternalError("codeSegmentSize is not power of 2: (" + codeSegmentSize + "), update JPECoffRelocObject");

        }

        this.codeEntryAlignment = graalHotSpotVMConfig.codeEntryAlignment;

        this.threadLocalHandshakes = graalHotSpotVMConfig.threadLocalHandshakes;

        // Section unique name is limited to 8 characters due to limitation on Windows.

        // Name could be longer but only first 8 characters are stored on Windows.

        // read only, code

        codeContainer = new CodeContainer(".text", this);

        // read only, info

        headerContainer = new HeaderContainer(jvmVersion, new ReadOnlyDataContainer(".header", this));

        configContainer = new ReadOnlyDataContainer(".config", this);

        metaspaceNamesContainer = new ReadOnlyDataContainer(".meta.names", this);

        methodsOffsetsContainer = new ReadOnlyDataContainer(".meth.offsets", this);

        klassesOffsetsContainer = new ReadOnlyDataContainer(".kls.offsets", this);

        klassesDependenciesContainer = new ReadOnlyDataContainer(".kls.dependencies", this);

        stubsOffsetsContainer = new ReadOnlyDataContainer(".stubs.offsets", this);

        codeSegmentsContainer = new ReadOnlyDataContainer(".code.segments", this);

        constantDataContainer = new ReadOnlyDataContainer(".meth.constdata", this);

        methodMetadataContainer = new ReadOnlyDataContainer(".meth.metadata", this);

        // writable sections

        oopGotContainer = new ByteContainer(".oop.got", this);

        klassesGotContainer = new ByteContainer(".kls.got", this);

        countersGotContainer = new ByteContainer(".cnt.got", this);

        metadataGotContainer = new ByteContainer(".meta.got", this);

        methodStateContainer = new ByteContainer(".meth.state", this);

        extLinkageGOTContainer = new ByteContainer(".got.linkage", this);

        addGlobalSymbols();

        recordConfiguration(graalHotSpotVMConfig, graphBuilderConfig, gc);

    }

    private void recordConfiguration(GraalHotSpotVMConfig graalHotSpotVMConfig, GraphBuilderConfiguration graphBuilderConfig, int gc) {

        // @Checkstyle: stop

        // @formatter:off

        boolean[] booleanFlags = { graalHotSpotVMConfig.cAssertions, // Debug VM

                                   graalHotSpotVMConfig.useCompressedOops,

                                   graalHotSpotVMConfig.useCompressedClassPointers,

                                   graalHotSpotVMConfig.compactFields,

                                   graalHotSpotVMConfig.useTLAB,

                                   graalHotSpotVMConfig.useBiasedLocking,

                                   TieredAOT.getValue(graalOptions),

                                   graalHotSpotVMConfig.enableContended,

                                   graalHotSpotVMConfig.restrictContended,

                                   graphBuilderConfig.omitAssertions(),

                                   graalHotSpotVMConfig.threadLocalHandshakes

        };

        int[] intFlags         = { graalHotSpotVMConfig.getOopEncoding().getShift(),

                                   graalHotSpotVMConfig.getKlassEncoding().getShift(),

                                   graalHotSpotVMConfig.contendedPaddingWidth,

                                   graalHotSpotVMConfig.fieldsAllocationStyle,

                                   1 << graalHotSpotVMConfig.logMinObjAlignment(),

                                   graalHotSpotVMConfig.codeSegmentSize,

                                   gc

        };

        // @formatter:on

        // @Checkstyle: resume

        byte[] booleanFlagsAsBytes = flagsToByteArray(booleanFlags);

        int size0 = configContainer.getByteStreamSize();

        // @formatter:off

        int computedSize = booleanFlagsAsBytes.length * Byte.BYTES    + // size of boolean flags

                           intFlags.length            * Integer.BYTES + // size of int flags

                           Integer.BYTES;                               // size of the "computedSize"

        configContainer.appendInt(computedSize).

                        appendInts(intFlags).

                        appendBytes(booleanFlagsAsBytes);

        // @formatter:on

        int size = configContainer.getByteStreamSize() - size0;

        assert size == computedSize;

    }

    private static byte[] flagsToByteArray(boolean[] flags) {

        byte[] byteArray = new byte[flags.length];

        for (int i = 0; i < flags.length; ++i) {

            byteArray[i] = boolToByte(flags[i]);

        }

        return byteArray;

    }

    private static byte boolToByte(boolean flag) {

        return (byte) (flag ? 1 : 0);

    }

    /**

     * Free some memory.

     */

    public void freeMemory() {

        offsetStringTable.clear();

        metaspaceNames.clear();

    }

    /*

     * Global symbol names in generated DSO corresponding to VM's symbols. VM needs to look up this

     * symbol in DSO and link it with VM's corresponding symbol: store VM's symbol address or value

     * in the named GOT cell.

     */

    public static String getCardTableAddressSymbolName() {

        return "_aot_card_table_address";

    }

    public static String getHeapTopAddressSymbolName() {

        return "_aot_heap_top_address";

    }

    public static String getHeapEndAddressSymbolName() {

        return "_aot_heap_end_address";

    }

    public static String getCrcTableAddressSymbolName() {

        return "_aot_stub_routines_crc_table_adr";

    }

    public static String getPollingPageSymbolName() {

        return "_aot_polling_page";

    }

    public static String getResolveStaticEntrySymbolName() {

        return "_resolve_static_entry";

    }

    public static String getResolveVirtualEntrySymbolName() {

        return "_resolve_virtual_entry";

    }

    public static String getResolveOptVirtualEntrySymbolName() {

        return "_resolve_opt_virtual_entry";

    }

    public static String getNarrowKlassBaseAddressSymbolName() {

        return "_aot_narrow_klass_base_address";

    }

    public static String getNarrowOopBaseAddressSymbolName() {

        return "_aot_narrow_oop_base_address";

    }

    public static String getLogOfHeapRegionGrainBytesSymbolName() {

        return "_aot_log_of_heap_region_grain_bytes";

    }

    public static String getInlineContiguousAllocationSupportedSymbolName() {

        return "_aot_inline_contiguous_allocation_supported";

    }

    public int getCodeSegmentSize() {

        return codeSegmentSize;

    }

    public int getCodeEntryAlignment() {

        return codeEntryAlignment;

    }

    public boolean getThreadLocalHandshakes() {

        return threadLocalHandshakes;

    }

    /**

     * Gets the global AOT symbol associated with the function name.

     *

     * @param functionName function name

     * @return AOT symbol for the given function name, or null if there is no mapping.

     */

    public static String getAOTSymbolForVMFunctionName(String functionName) {

        return functionNamesToAOTSymbols.get(functionName);

    }

    private void addGlobalSymbols() {

        // Create global symbols for all containers.

        createContainerSymbol(codeContainer);

        createContainerSymbol(configContainer);

        createContainerSymbol(methodsOffsetsContainer);

        createContainerSymbol(klassesOffsetsContainer);

        createContainerSymbol(klassesDependenciesContainer);

        createContainerSymbol(klassesGotContainer);

        createContainerSymbol(countersGotContainer);

        createContainerSymbol(metadataGotContainer);

        createContainerSymbol(methodStateContainer);

        createContainerSymbol(oopGotContainer);

        createContainerSymbol(metaspaceNamesContainer);

        createContainerSymbol(methodMetadataContainer);

        createContainerSymbol(stubsOffsetsContainer);

        createContainerSymbol(headerContainer.getContainer());

        createContainerSymbol(codeSegmentsContainer);

        createGotSymbol(getResolveStaticEntrySymbolName());

        createGotSymbol(getResolveVirtualEntrySymbolName());

        createGotSymbol(getResolveOptVirtualEntrySymbolName());

        createGotSymbol(getCardTableAddressSymbolName());

        createGotSymbol(getHeapTopAddressSymbolName());

        createGotSymbol(getHeapEndAddressSymbolName());

        createGotSymbol(getNarrowKlassBaseAddressSymbolName());

        createGotSymbol(getNarrowOopBaseAddressSymbolName());

        createGotSymbol(getPollingPageSymbolName());

        createGotSymbol(getLogOfHeapRegionGrainBytesSymbolName());

        createGotSymbol(getInlineContiguousAllocationSupportedSymbolName());

        for (HashMap.Entry<String, String> entry : functionNamesToAOTSymbols.entrySet()) {

            createGotSymbol(entry.getValue());

        }

    }

    /**

     * Creates a global symbol of the form {@code "A" + container name}. Note, linker on Windows

     * does not allow names which start with '.'

     *

     * @param container container to create a symbol for

     */

    private static void createContainerSymbol(ByteContainer container) {