1 /* 2 * Copyright (c) 2012, 2019, 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.HotSpotGCProvider; 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.options.OptionValues; 55 import org.graalvm.compiler.phases.common.AddressLoweringPhase; 56 import org.graalvm.compiler.phases.tiers.CompilerConfiguration; 57 import org.graalvm.compiler.phases.util.Providers; 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 extends 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 = createConstantFieldProvider(config, metaAccess); 98 Value[] nativeABICallerSaveRegisters = createNativeABICallerSaveRegisters(config, codeCache.getRegisterConfig()); 99 HotSpotWordTypes wordTypes = createWordTypes(metaAccess, target); 100 HotSpotForeignCallsProvider foreignCalls = new SPARCHotSpotForeignCallsProvider(jvmciRuntime, runtime, metaAccess, codeCache, wordTypes, nativeABICallerSaveRegisters); 101 LoweringProvider lowerer = createLowerer(runtime, metaAccess, foreignCalls, registers, constantReflection, target); 102 HotSpotStampProvider stampProvider = createStampProvider(); 103 HotSpotGCProvider gc = createGCProvider(config); 104 Providers p = new Providers(metaAccess, codeCache, constantReflection, constantFieldProvider, foreignCalls, lowerer, null, stampProvider, gc); 105 HotSpotSnippetReflectionProvider snippetReflection = createSnippetReflection(runtime, constantReflection, wordTypes); 106 BytecodeProvider bytecodeProvider = createBytecodeProvider(metaAccess, snippetReflection); 107 HotSpotReplacementsImpl replacements = createReplacements(target, p, snippetReflection, bytecodeProvider); 108 Plugins plugins = createGraphBuilderPlugins(runtime, compilerConfiguration, config, metaAccess, constantReflection, foreignCalls, snippetReflection, replacements, wordTypes, 109 runtime.getOptions()); 110 replacements.setGraphBuilderPlugins(plugins); 111 HotSpotSuitesProvider suites = createSuites(config, runtime, compilerConfiguration, plugins, replacements); 112 HotSpotProviders providers = new HotSpotProviders(metaAccess, codeCache, constantReflection, constantFieldProvider, foreignCalls, lowerer, replacements, suites, registers, 113 snippetReflection, wordTypes, plugins, gc); 114 replacements.setProviders(providers); 115 116 return createBackend(config, runtime, providers); 117 } 118 119 protected Plugins createGraphBuilderPlugins(HotSpotGraalRuntimeProvider graalRuntime, 120 CompilerConfiguration compilerConfiguration, 121 GraalHotSpotVMConfig config, 122 HotSpotMetaAccessProvider metaAccess, 123 HotSpotConstantReflectionProvider constantReflection, 124 HotSpotForeignCallsProvider foreignCalls, 125 HotSpotSnippetReflectionProvider snippetReflection, 126 HotSpotReplacementsImpl replacements, 127 HotSpotWordTypes wordTypes, 128 OptionValues options) { 129 Plugins plugins = HotSpotGraphBuilderPlugins.create( 130 graalRuntime, 131 compilerConfiguration, 132 config, 133 wordTypes, 134 metaAccess, 135 constantReflection, 136 snippetReflection, 137 foreignCalls, 138 replacements, 139 options); 140 SPARCGraphBuilderPlugins.register(plugins, replacements.getDefaultReplacementBytecodeProvider(), false); 141 return plugins; 142 } 143 144 /** 145 * @param replacements 146 */ 147 protected HotSpotSuitesProvider createSuites(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, CompilerConfiguration compilerConfiguration, Plugins plugins, 148 Replacements replacements) { 149 return new AddressLoweringHotSpotSuitesProvider(new SPARCSuitesCreator(compilerConfiguration, plugins), config, runtime, new AddressLoweringPhase(new SPARCAddressLowering())); 150 } 151 152 protected SPARCHotSpotBackend createBackend(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, HotSpotProviders providers) { 153 return new SPARCHotSpotBackend(config, runtime, providers); 154 } 155 156 protected HotSpotLoweringProvider createLowerer(HotSpotGraalRuntimeProvider runtime, HotSpotMetaAccessProvider metaAccess, HotSpotForeignCallsProvider foreignCalls, 157 HotSpotRegistersProvider registers, HotSpotConstantReflectionProvider constantReflection, TargetDescription target) { 158 return new SPARCHotSpotLoweringProvider(runtime, metaAccess, foreignCalls, registers, constantReflection, target); 159 } 160 161 protected HotSpotRegistersProvider createRegisters() { 162 return new HotSpotRegisters(SPARC.g2, SPARC.g6, SPARC.sp); 163 } 164 165 @SuppressWarnings("unused") 166 private static Value[] createNativeABICallerSaveRegisters(GraalHotSpotVMConfig config, RegisterConfig regConfig) { 167 Set<Register> callerSavedRegisters = new HashSet<>(); 168 SPARC.fpusRegisters.addTo(callerSavedRegisters); 169 SPARC.fpudRegisters.addTo(callerSavedRegisters); 170 callerSavedRegisters.add(SPARC.g1); 171 callerSavedRegisters.add(SPARC.g4); 172 callerSavedRegisters.add(SPARC.g5); 173 Value[] nativeABICallerSaveRegisters = new Value[callerSavedRegisters.size()]; 174 int i = 0; 175 for (Register reg : callerSavedRegisters) { 176 nativeABICallerSaveRegisters[i] = reg.asValue(); 177 i++; 178 } 179 return nativeABICallerSaveRegisters; 180 } 181 182 @Override 183 public String toString() { 184 return "SPARC"; 185 } 186 }