1 /* 2 * Copyright (c) 2012, 2016, 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 package org.graalvm.compiler.hotspot.sparc; 26 27 import java.util.HashSet; 28 import java.util.Set; 29 30 import org.graalvm.compiler.bytecode.BytecodeProvider; 31 import org.graalvm.compiler.core.sparc.SPARCAddressLowering; 32 import org.graalvm.compiler.core.sparc.SPARCSuitesCreator; 33 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig; 34 import org.graalvm.compiler.hotspot.HotSpotBackend; 35 import org.graalvm.compiler.hotspot.HotSpotBackendFactory; 36 import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider; 37 import org.graalvm.compiler.hotspot.HotSpotReplacementsImpl; 38 import org.graalvm.compiler.hotspot.meta.AddressLoweringHotSpotSuitesProvider; 39 import org.graalvm.compiler.hotspot.meta.HotSpotConstantFieldProvider; 40 import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider; 41 import org.graalvm.compiler.hotspot.meta.HotSpotGraalConstantFieldProvider; 42 import org.graalvm.compiler.hotspot.meta.HotSpotGraphBuilderPlugins; 43 import org.graalvm.compiler.hotspot.meta.HotSpotLoweringProvider; 44 import org.graalvm.compiler.hotspot.meta.HotSpotProviders; 45 import org.graalvm.compiler.hotspot.meta.HotSpotRegisters; 46 import org.graalvm.compiler.hotspot.meta.HotSpotRegistersProvider; 47 import org.graalvm.compiler.hotspot.meta.HotSpotSnippetReflectionProvider; 48 import org.graalvm.compiler.hotspot.meta.HotSpotStampProvider; 49 import org.graalvm.compiler.hotspot.meta.HotSpotSuitesProvider; 50 import org.graalvm.compiler.hotspot.word.HotSpotWordTypes; 51 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; 52 import org.graalvm.compiler.nodes.spi.LoweringProvider; 53 import org.graalvm.compiler.nodes.spi.Replacements; 54 import org.graalvm.compiler.phases.common.AddressLoweringPhase; 55 import org.graalvm.compiler.phases.tiers.CompilerConfiguration; 56 import org.graalvm.compiler.phases.util.Providers; 57 import org.graalvm.compiler.replacements.classfile.ClassfileBytecodeProvider; 58 import org.graalvm.compiler.replacements.sparc.SPARCGraphBuilderPlugins; 59 import org.graalvm.compiler.serviceprovider.ServiceProvider; 60 61 import jdk.vm.ci.code.Architecture; 62 import jdk.vm.ci.code.Register; 63 import jdk.vm.ci.code.RegisterConfig; 64 import jdk.vm.ci.code.TargetDescription; 65 import jdk.vm.ci.hotspot.HotSpotCodeCacheProvider; 66 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider; 67 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime; 68 import jdk.vm.ci.hotspot.HotSpotMetaAccessProvider; 69 import jdk.vm.ci.meta.Value; 70 import jdk.vm.ci.runtime.JVMCIBackend; 71 import jdk.vm.ci.sparc.SPARC; 72 73 @ServiceProvider(HotSpotBackendFactory.class) 74 public class SPARCHotSpotBackendFactory implements HotSpotBackendFactory { 75 76 @Override 77 public String getName() { 78 return "community"; 79 } 80 81 @Override 82 public Class<? extends Architecture> getArchitecture() { 83 return SPARC.class; 84 } 85 86 @Override 87 public HotSpotBackend createBackend(HotSpotGraalRuntimeProvider runtime, CompilerConfiguration compilerConfiguration, HotSpotJVMCIRuntime jvmciRuntime, HotSpotBackend host) { 88 assert host == null; 89 90 GraalHotSpotVMConfig config = runtime.getVMConfig(); 91 JVMCIBackend jvmci = jvmciRuntime.getHostJVMCIBackend(); 92 HotSpotRegistersProvider registers = createRegisters(); 93 HotSpotMetaAccessProvider metaAccess = (HotSpotMetaAccessProvider) jvmci.getMetaAccess(); 94 HotSpotCodeCacheProvider codeCache = (HotSpotCodeCacheProvider) jvmci.getCodeCache(); 95 TargetDescription target = codeCache.getTarget(); 96 HotSpotConstantReflectionProvider constantReflection = (HotSpotConstantReflectionProvider) jvmci.getConstantReflection(); 97 HotSpotConstantFieldProvider constantFieldProvider = new HotSpotGraalConstantFieldProvider(config, metaAccess); 98 Value[] nativeABICallerSaveRegisters = createNativeABICallerSaveRegisters(config, codeCache.getRegisterConfig()); 99 HotSpotWordTypes wordTypes = new HotSpotWordTypes(metaAccess, target.wordJavaKind); 100 HotSpotForeignCallsProvider foreignCalls = new SPARCHotSpotForeignCallsProvider(jvmciRuntime, runtime, metaAccess, codeCache, wordTypes, nativeABICallerSaveRegisters); 101 LoweringProvider lowerer = createLowerer(runtime, metaAccess, foreignCalls, registers, constantReflection, target); 102 HotSpotStampProvider stampProvider = new HotSpotStampProvider(); 103 Providers p = new Providers(metaAccess, codeCache, constantReflection, constantFieldProvider, foreignCalls, lowerer, null, stampProvider); 104 HotSpotSnippetReflectionProvider snippetReflection = new HotSpotSnippetReflectionProvider(runtime, constantReflection, wordTypes); 105 BytecodeProvider bytecodeProvider = new ClassfileBytecodeProvider(metaAccess, snippetReflection); 106 HotSpotReplacementsImpl replacements = new HotSpotReplacementsImpl(runtime.getOptions(), p, snippetReflection, bytecodeProvider, target); 107 Plugins plugins = createGraphBuilderPlugins(compilerConfiguration, config, metaAccess, constantReflection, foreignCalls, lowerer, stampProvider, snippetReflection, replacements, wordTypes); 108 replacements.setGraphBuilderPlugins(plugins); 109 HotSpotSuitesProvider suites = createSuites(config, runtime, compilerConfiguration, plugins, replacements); 110 HotSpotProviders providers = new HotSpotProviders(metaAccess, codeCache, constantReflection, constantFieldProvider, foreignCalls, lowerer, replacements, suites, registers, 111 snippetReflection, 112 wordTypes, plugins); 113 114 return createBackend(config, runtime, providers); 115 } 116 117 protected Plugins createGraphBuilderPlugins(CompilerConfiguration compilerConfiguration, GraalHotSpotVMConfig config, HotSpotMetaAccessProvider metaAccess, 118 HotSpotConstantReflectionProvider constantReflection, HotSpotForeignCallsProvider foreignCalls, LoweringProvider lowerer, HotSpotStampProvider stampProvider, 119 HotSpotSnippetReflectionProvider snippetReflection, HotSpotReplacementsImpl replacements, HotSpotWordTypes wordTypes) { 120 Plugins plugins = HotSpotGraphBuilderPlugins.create(compilerConfiguration, config, wordTypes, metaAccess, constantReflection, snippetReflection, foreignCalls, lowerer, stampProvider, 121 replacements); 122 SPARCGraphBuilderPlugins.register(plugins, replacements.getDefaultReplacementBytecodeProvider(), false); 123 return plugins; 124 } 125 126 /** 127 * @param replacements 128 */ 129 protected HotSpotSuitesProvider createSuites(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, CompilerConfiguration compilerConfiguration, Plugins plugins, 130 Replacements replacements) { 131 return new AddressLoweringHotSpotSuitesProvider(new SPARCSuitesCreator(compilerConfiguration, plugins), config, runtime, new AddressLoweringPhase(new SPARCAddressLowering())); 132 } 133 134 protected SPARCHotSpotBackend createBackend(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, HotSpotProviders providers) { 135 return new SPARCHotSpotBackend(config, runtime, providers); 136 } 137 138 protected HotSpotLoweringProvider createLowerer(HotSpotGraalRuntimeProvider runtime, HotSpotMetaAccessProvider metaAccess, HotSpotForeignCallsProvider foreignCalls, 139 HotSpotRegistersProvider registers, HotSpotConstantReflectionProvider constantReflection, TargetDescription target) { 140 return new SPARCHotSpotLoweringProvider(runtime, metaAccess, foreignCalls, registers, constantReflection, target); 141 } 142 143 protected HotSpotRegistersProvider createRegisters() { 144 return new HotSpotRegisters(SPARC.g2, SPARC.g6, SPARC.sp); 145 } 146 147 @SuppressWarnings("unused") 148 private static Value[] createNativeABICallerSaveRegisters(GraalHotSpotVMConfig config, RegisterConfig regConfig) { 149 Set<Register> callerSavedRegisters = new HashSet<>(); 150 SPARC.fpusRegisters.addTo(callerSavedRegisters); 151 SPARC.fpudRegisters.addTo(callerSavedRegisters); 152 callerSavedRegisters.add(SPARC.g1); 153 callerSavedRegisters.add(SPARC.g4); 154 callerSavedRegisters.add(SPARC.g5); 155 Value[] nativeABICallerSaveRegisters = new Value[callerSavedRegisters.size()]; 156 int i = 0; 157 for (Register reg : callerSavedRegisters) { 158 nativeABICallerSaveRegisters[i] = reg.asValue(); 159 i++; 160 } 161 return nativeABICallerSaveRegisters; 162 } 163 164 @Override 165 public String toString() { 166 return "SPARC"; 167 } 168 }