https://www.graalvm.org/ 
/*
 * Copyright (c) 2016, 2018, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

import org.graalvm.compiler.code.CompilationResult;
import org.graalvm.compiler.debug.DebugContext;
import org.graalvm.compiler.hotspot.HotSpotHostBackend;
import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
import org.graalvm.compiler.hotspot.stubs.Stub;

import jdk.tools.jaotc.binformat.BinaryContainer;
import jdk.tools.jaotc.binformat.ByteContainer;
import jdk.tools.jaotc.binformat.HeaderContainer;
import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
import jdk.vm.ci.hotspot.HotSpotVMConfigStore;
import jdk.vm.ci.hotspot.VMField;

final class DataBuilder {

    private final Main main;

    private final HotSpotHostBackend backend;

    private final List<AOTCompiledClass> classes;

    
Target-independent container in which text symbols and code bytes are created.

/**
     * Target-independent container in which text symbols and code bytes are created.
     */
    private final BinaryContainer binaryContainer;

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

    DataBuilder(Main main, HotSpotHostBackend backend, List<AOTCompiledClass> classes, BinaryContainer binaryContainer) {
        this.main = main;
        this.backend = backend;
        this.classes = classes;
        this.binaryContainer = binaryContainer;
        fillVMAddresses(HotSpotJVMCIRuntime.runtime().getConfigStore());
    }

    
Returns a value-name map of all VMField fields. 
/**
     * Returns a value-name map of all {@link VMField} fields.
     */
    private static void fillVMAddresses(HotSpotVMConfigStore config) {
        for (VMField vmField : config.getFields().values()) {
            if (vmField.value != null && vmField.value instanceof Long) {
                final long address = (Long) vmField.value;
                String value = vmField.name;
                /*
                 * Some fields don't contain addresses but integer values. At least don't add zero
                 * entries to avoid matching null addresses.
                 */
                if (address != 0) {
                    vmAddresses.put(address, value);
                }
            }
        }
        for (Entry<String, Long> vmAddress : config.getAddresses().entrySet()) {
            final long address = vmAddress.getValue();
            String value = vmAddress.getKey();
            String old = vmAddresses.put(address, value);
            if (old != null) {
                throw new InternalError("already in map: address: " + address + ", current: " + value + ", old: " + old);
            }
        }
    }

    
Get the C/C++ function name associated with the foreign call target address. 
Params:
  • address – native address
Returns:C/C++ functio name associated with the native address
/**
     * Get the C/C++ function name associated with the foreign call target {@code address}.
     *
     * @param address native address
     * @return C/C++ functio name associated with the native address
     */
    static String getVMFunctionNameForAddress(long address) {
        return vmAddresses.get(address);
    }

    
Returns the host backend used for this compilation.

Returns:host backend
/**
     * Returns the host backend used for this compilation.
     *
     * @return host backend
     */
    HotSpotHostBackend getBackend() {
        return backend;
    }

    
Returns the binary container for this compilation.

Returns:binary container
/**
     * Returns the binary container for this compilation.
     *
     * @return binary container
     */
    BinaryContainer getBinaryContainer() {
        return binaryContainer;
    }

    
Prepare data with all compiled classes and stubs.

Params:
  • debug – 
Throws:
/**
     * Prepare data with all compiled classes and stubs.
     *
     * @param debug
     *
     * @throws Exception
     */
    @SuppressWarnings("try")
    void prepareData(DebugContext debug) throws Exception {
        try (Timer t = new Timer(main, "Parsing compiled code")) {
            /*
             * Copy compiled code into code section container and calls stubs (PLT trampoline).
             */
            CodeSectionProcessor codeSectionProcessor = new CodeSectionProcessor(this);
            for (AOTCompiledClass c : classes) {
                // For each class we need 2 GOT slots:
                // first - for initialized klass
                // second - only for loaded klass
                c.addAOTKlassData(binaryContainer);
                codeSectionProcessor.process(c);
            }
        }

        AOTCompiledClass stubCompiledCode = retrieveStubCode(debug);

        // Free memory!
        try (Timer t = main.options.verbose ? new Timer(main, "Freeing memory") : null) {
            main.printer.printMemoryUsage();
            System.gc();
        }

        MetadataBuilder metadataBuilder = null;
        try (Timer t = new Timer(main, "Processing metadata")) {
            /*
             * Generate metadata for compiled code and copy it into metadata section. Create
             * relocation information for all references (call, constants, etc) in compiled code.
             */
            metadataBuilder = new MetadataBuilder(this);
            metadataBuilder.processMetadata(classes, stubCompiledCode);
        }

        // Free memory!
        try (Timer t = main.options.verbose ? new Timer(main, "Freeing memory") : null) {
            main.printer.printMemoryUsage();
            System.gc();
        }

        try (Timer t = new Timer(main, "Preparing stubs binary")) {
            prepareStubsBinary(stubCompiledCode);
        }
        try (Timer t = new Timer(main, "Preparing compiled binary")) {
            // Should be called after Stubs because they can set dependent klasses.
            prepareCompiledBinary();
        }
    }

    
Get all stubs from Graal and add them to the code section.

Params:
  • debug – 
/**
     * Get all stubs from Graal and add them to the code section.
     *
     * @param debug
     */
    @SuppressWarnings("try")
    private AOTCompiledClass retrieveStubCode(DebugContext debug) {
        ArrayList<CompiledMethodInfo> stubs = new ArrayList<>();
        HotSpotForeignCallsProvider foreignCallsProvider = backend.getProviders().getForeignCalls();
        for (Stub stub : foreignCallsProvider.getStubs()) {
            try (DebugContext.Scope scope = debug.scope("CompileStubs")) {
                CompilationResult result = stub.getCompilationResult(debug, backend);
                CompiledMethodInfo cm = new CompiledMethodInfo(result, new AOTStub(stub, backend, debug.getOptions()));
                stubs.add(cm);
            } catch (Throwable e) {
                throw debug.handle(e);
            }
        }
        AOTCompiledClass stubCompiledCode = new AOTCompiledClass(stubs);
        CodeSectionProcessor codeSectionProcessor = new CodeSectionProcessor(this);
        codeSectionProcessor.process(stubCompiledCode);
        return stubCompiledCode;
    }

    
Prepare metaspace.offsets section.

/**
     * Prepare metaspace.offsets section.
     */
    private void prepareCompiledBinary() {
        for (AOTCompiledClass c : classes) {
            // Create records for compiled AOT methods.
            c.putMethodsData(binaryContainer);
        }
        // Create records for compiled AOT classes.
        AOTCompiledClass.putAOTKlassData(binaryContainer);

        // Fill in AOTHeader
        HeaderContainer header = binaryContainer.getHeaderContainer();
        header.setClassesCount(AOTCompiledClass.getClassesCount());
        header.setMethodsCount(CompiledMethodInfo.getMethodsCount());
        // Record size of got sections
        ByteContainer bc = binaryContainer.getKlassesGotContainer();
        header.setKlassesGotSize((bc.getByteStreamSize() / 8));
        bc = binaryContainer.getMetadataGotContainer();
        header.setMetadataGotSize((bc.getByteStreamSize() / 8));
        bc = binaryContainer.getOopGotContainer();
        header.setOopGotSize((bc.getByteStreamSize() / 8));
    }

    
Prepare stubs.offsets section.

/**
     * Prepare stubs.offsets section.
     */
    private void prepareStubsBinary(AOTCompiledClass compiledClass) {
        // For each of the compiled stubs, create records holding information about
        // them.
        ArrayList<CompiledMethodInfo> compiledStubs = compiledClass.getCompiledMethods();
        int cntStubs = compiledStubs.size();
        BinaryContainer.addMethodsCount(cntStubs, binaryContainer.getStubsOffsetsContainer());
        for (CompiledMethodInfo methodInfo : compiledStubs) {
            // Note, stubs have different offsets container.
            methodInfo.addMethodOffsets(binaryContainer, binaryContainer.getStubsOffsetsContainer());
        }
    }

}