rev 52889 : 8214023: Update Graal

   1 /*
   2  * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 
  26 package jdk.tools.jaotc;
  27 
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map.Entry;
  32 
  33 import org.graalvm.compiler.code.CompilationResult;
  34 import org.graalvm.compiler.debug.DebugContext;
  35 import org.graalvm.compiler.hotspot.HotSpotHostBackend;
  36 import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
  37 import org.graalvm.compiler.hotspot.stubs.Stub;
  38 
  39 import jdk.tools.jaotc.binformat.BinaryContainer;
  40 import jdk.tools.jaotc.binformat.ByteContainer;
  41 import jdk.tools.jaotc.binformat.HeaderContainer;
  42 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
  43 import jdk.vm.ci.hotspot.HotSpotVMConfigStore;
  44 import jdk.vm.ci.hotspot.VMField;
  45 
  46 final class DataBuilder {
  47 
  48     private final Main main;
  49 
  50     private final HotSpotHostBackend backend;
  51 
  52     private final List<AOTCompiledClass> classes;
  53 
  54     /**
  55      * Target-independent container in which text symbols and code bytes are created.
  56      */
  57     private final BinaryContainer binaryContainer;
  58 
  59     private static final HashMap<Long, String> vmAddresses = new HashMap<>();
  60 
  61     DataBuilder(Main main, HotSpotHostBackend backend, List<AOTCompiledClass> classes, BinaryContainer binaryContainer) {
  62         this.main = main;
  63         this.backend = backend;
  64         this.classes = classes;
  65         this.binaryContainer = binaryContainer;
  66         fillVMAddresses(HotSpotJVMCIRuntime.runtime().getConfigStore());
  67     }
  68 
  69     /**
  70      * Returns a value-name map of all {@link VMField} fields.
  71      */
  72     private static void fillVMAddresses(HotSpotVMConfigStore config) {
  73         for (VMField vmField : config.getFields().values()) {
  74             if (vmField.value != null && vmField.value instanceof Long) {
  75                 final long address = (Long) vmField.value;
  76                 String value = vmField.name;
  77                 /*
  78                  * Some fields don't contain addresses but integer values. At least don't add zero
  79                  * entries to avoid matching null addresses.
  80                  */
  81                 if (address != 0) {
  82                     vmAddresses.put(address, value);
  83                 }
  84             }
  85         }
  86         for (Entry<String, Long> vmAddress : config.getAddresses().entrySet()) {
  87             final long address = vmAddress.getValue();
  88             String value = vmAddress.getKey();
  89             String old = vmAddresses.put(address, value);
  90             if (old != null) {
  91                 throw new InternalError("already in map: address: " + address + ", current: " + value + ", old: " + old);
  92             }
  93         }
  94     }
  95 
  96     /**
  97      * Get the C/C++ function name associated with the foreign call target {@code address}.
  98      *
  99      * @param address native address
 100      * @return C/C++ functio name associated with the native address
 101      */
 102     static String getVMFunctionNameForAddress(long address) {
 103         return vmAddresses.get(address);
 104     }
 105 
 106     /**
 107      * Returns the host backend used for this compilation.
 108      *
 109      * @return host backend
 110      */
 111     HotSpotHostBackend getBackend() {
 112         return backend;
 113     }
 114 
 115     /**
 116      * Returns the binary container for this compilation.
 117      *
 118      * @return binary container
 119      */
 120     BinaryContainer getBinaryContainer() {
 121         return binaryContainer;
 122     }
 123 
 124     /**
 125      * Prepare data with all compiled classes and stubs.
 126      *
 127      * @param debug
 128      *
 129      * @throws Exception
 130      */
 131     @SuppressWarnings("try")
 132     void prepareData(DebugContext debug) throws Exception {
 133         try (Timer t = new Timer(main, "Parsing compiled code")) {
 134             /*
 135              * Copy compiled code into code section container and calls stubs (PLT trampoline).
 136              */
 137             CodeSectionProcessor codeSectionProcessor = new CodeSectionProcessor(this);
 138             for (AOTCompiledClass c : classes) {
 139                 // For each class we need 2 GOT slots:
 140                 // first - for initialized klass
 141                 // second - only for loaded klass
 142                 c.addAOTKlassData(binaryContainer);
 143                 codeSectionProcessor.process(c);
 144             }
 145         }
 146 
 147         AOTCompiledClass stubCompiledCode = retrieveStubCode(debug);
 148 
 149         // Free memory!
 150         try (Timer t = main.options.verbose ? new Timer(main, "Freeing memory") : null) {
 151             main.printer.printMemoryUsage();
 152             System.gc();
 153         }
 154 
 155         MetadataBuilder metadataBuilder = null;
 156         try (Timer t = new Timer(main, "Processing metadata")) {
 157             /*
 158              * Generate metadata for compiled code and copy it into metadata section. Create
 159              * relocation information for all references (call, constants, etc) in compiled code.
 160              */
 161             metadataBuilder = new MetadataBuilder(this);
 162             metadataBuilder.processMetadata(classes, stubCompiledCode);
 163         }
 164 
 165         // Free memory!
 166         try (Timer t = main.options.verbose ? new Timer(main, "Freeing memory") : null) {
 167             main.printer.printMemoryUsage();
 168             System.gc();
 169         }
 170 
 171         try (Timer t = new Timer(main, "Preparing stubs binary")) {
 172             prepareStubsBinary(stubCompiledCode);
 173         }
 174         try (Timer t = new Timer(main, "Preparing compiled binary")) {
 175             // Should be called after Stubs because they can set dependent klasses.
 176             prepareCompiledBinary();
 177         }
 178     }
 179 
 180     /**
 181      * Get all stubs from Graal and add them to the code section.
 182      *
 183      * @param debug
 184      */
 185     @SuppressWarnings("try")
 186     private AOTCompiledClass retrieveStubCode(DebugContext debug) {
 187         ArrayList<CompiledMethodInfo> stubs = new ArrayList<>();
 188         HotSpotForeignCallsProvider foreignCallsProvider = backend.getProviders().getForeignCalls();
 189         for (Stub stub : foreignCallsProvider.getStubs()) {
 190             try (DebugContext.Scope scope = debug.scope("CompileStubs")) {
 191                 CompilationResult result = stub.getCompilationResult(debug, backend);
 192                 CompiledMethodInfo cm = new CompiledMethodInfo(result, new AOTStub(stub, backend, debug.getOptions()));
 193                 stubs.add(cm);
 194             } catch (Throwable e) {
 195                 throw debug.handle(e);
 196             }
 197         }
 198         AOTCompiledClass stubCompiledCode = new AOTCompiledClass(stubs);
 199         CodeSectionProcessor codeSectionProcessor = new CodeSectionProcessor(this);
 200         codeSectionProcessor.process(stubCompiledCode);
 201         return stubCompiledCode;
 202     }
 203 
 204     /**
 205      * Prepare metaspace.offsets section.
 206      */
 207     private void prepareCompiledBinary() {
 208         for (AOTCompiledClass c : classes) {
 209             // Create records for compiled AOT methods.
 210             c.putMethodsData(binaryContainer);
 211         }
 212         // Create records for compiled AOT classes.
 213         AOTCompiledClass.putAOTKlassData(binaryContainer);
 214 
 215         // Fill in AOTHeader
 216         HeaderContainer header = binaryContainer.getHeaderContainer();
 217         header.setClassesCount(AOTCompiledClass.getClassesCount());
 218         header.setMethodsCount(CompiledMethodInfo.getMethodsCount());
 219         // Record size of got sections
 220         ByteContainer bc = binaryContainer.getKlassesGotContainer();
 221         header.setKlassesGotSize((bc.getByteStreamSize() / 8));
 222         bc = binaryContainer.getMetadataGotContainer();
 223         header.setMetadataGotSize((bc.getByteStreamSize() / 8));
 224         bc = binaryContainer.getOopGotContainer();
 225         header.setOopGotSize((bc.getByteStreamSize() / 8));
 226     }
 227 
 228     /**
 229      * Prepare stubs.offsets section.
 230      */
 231     private void prepareStubsBinary(AOTCompiledClass compiledClass) {
 232         // For each of the compiled stubs, create records holding information about
 233         // them.
 234         ArrayList<CompiledMethodInfo> compiledStubs = compiledClass.getCompiledMethods();
 235         int cntStubs = compiledStubs.size();
 236         BinaryContainer.addMethodsCount(cntStubs, binaryContainer.getStubsOffsetsContainer());
 237         for (CompiledMethodInfo methodInfo : compiledStubs) {
 238             // Note, stubs have different offsets container.
 239             methodInfo.addMethodOffsets(binaryContainer, binaryContainer.getStubsOffsetsContainer());
 240         }
 241     }
 242 
 243 }
--- EOF ---