1 /* 2 * Copyright (c) 2012, 2020, 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.HotSpotPlatformConfigurationProvider; 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.PlatformConfigurationProvider; 54 import org.graalvm.compiler.nodes.spi.Replacements; 55 import org.graalvm.compiler.options.OptionValues; 56 import org.graalvm.compiler.phases.common.AddressLoweringPhase; 57 import org.graalvm.compiler.phases.tiers.CompilerConfiguration; 58 import org.graalvm.compiler.phases.util.Providers; 59 import org.graalvm.compiler.replacements.sparc.SPARCGraphBuilderPlugins; 60 import org.graalvm.compiler.serviceprovider.ServiceProvider; 61 62 import jdk.vm.ci.code.Architecture; 63 import jdk.vm.ci.code.Register; 64 import jdk.vm.ci.code.RegisterConfig; 65 import jdk.vm.ci.code.TargetDescription; 66 import jdk.vm.ci.hotspot.HotSpotCodeCacheProvider; 67 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider; 68 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime; 69 import jdk.vm.ci.hotspot.HotSpotMetaAccessProvider; 70 import jdk.vm.ci.meta.Value; 71 import jdk.vm.ci.runtime.JVMCIBackend; 72 import jdk.vm.ci.sparc.SPARC; 73 74 @ServiceProvider(HotSpotBackendFactory.class) 75 public class SPARCHotSpotBackendFactory extends HotSpotBackendFactory { 76 77 @Override 78 public String getName() { 79 return "community"; 80 } 81 82 @Override 83 public Class<? extends Architecture> getArchitecture() { 84 return SPARC.class; 85 } 86 87 @Override 88 public HotSpotBackend createBackend(HotSpotGraalRuntimeProvider runtime, CompilerConfiguration compilerConfiguration, HotSpotJVMCIRuntime jvmciRuntime, HotSpotBackend host) { 89 assert host == null; 90 91 OptionValues options = runtime.getOptions(); 92 GraalHotSpotVMConfig config = runtime.getVMConfig(); 93 JVMCIBackend jvmci = jvmciRuntime.getHostJVMCIBackend(); 94 HotSpotRegistersProvider registers = createRegisters(); 95 HotSpotMetaAccessProvider metaAccess = (HotSpotMetaAccessProvider) jvmci.getMetaAccess(); 96 HotSpotCodeCacheProvider codeCache = (HotSpotCodeCacheProvider) jvmci.getCodeCache(); 97 TargetDescription target = codeCache.getTarget(); 98 HotSpotConstantReflectionProvider constantReflection = (HotSpotConstantReflectionProvider) jvmci.getConstantReflection(); 99 HotSpotConstantFieldProvider constantFieldProvider = createConstantFieldProvider(config, metaAccess); 100 Value[] nativeABICallerSaveRegisters = createNativeABICallerSaveRegisters(config, codeCache.getRegisterConfig()); 101 HotSpotWordTypes wordTypes = createWordTypes(metaAccess, target); 102 HotSpotForeignCallsProvider foreignCalls = new SPARCHotSpotForeignCallsProvider(jvmciRuntime, runtime, metaAccess, codeCache, wordTypes, nativeABICallerSaveRegisters); 103 HotSpotStampProvider stampProvider = createStampProvider(); 104 HotSpotPlatformConfigurationProvider platformConfigurationProvider = createConfigInfoProvider(config, metaAccess); 105 LoweringProvider lowerer = createLowerer(runtime, metaAccess, foreignCalls, registers, constantReflection, platformConfigurationProvider, target); 106 Providers p = new Providers(metaAccess, codeCache, constantReflection, constantFieldProvider, foreignCalls, lowerer, null, stampProvider, platformConfigurationProvider); 107 HotSpotSnippetReflectionProvider snippetReflection = createSnippetReflection(runtime, constantReflection, wordTypes); 108 BytecodeProvider bytecodeProvider = createBytecodeProvider(metaAccess, snippetReflection); 109 HotSpotReplacementsImpl replacements = createReplacements(target, p, snippetReflection, bytecodeProvider); 110 Plugins plugins = createGraphBuilderPlugins(runtime, compilerConfiguration, config, metaAccess, constantReflection, foreignCalls, snippetReflection, replacements, wordTypes, 111 runtime.getOptions(), target); 112 replacements.setGraphBuilderPlugins(plugins); 113 HotSpotSuitesProvider suites = createSuites(config, runtime, compilerConfiguration, plugins, replacements); 114 HotSpotProviders providers = new HotSpotProviders(metaAccess, codeCache, constantReflection, constantFieldProvider, foreignCalls, lowerer, replacements, suites, registers, 115 snippetReflection, wordTypes, plugins, platformConfigurationProvider); 116 replacements.setProviders(providers); 117 replacements.maybeInitializeEncoder(options); 118 119 return createBackend(config, runtime, providers); 120 } 121 122 protected Plugins createGraphBuilderPlugins(HotSpotGraalRuntimeProvider graalRuntime, 123 CompilerConfiguration compilerConfiguration, 124 GraalHotSpotVMConfig config, 125 HotSpotMetaAccessProvider metaAccess, 126 HotSpotConstantReflectionProvider constantReflection, 127 HotSpotForeignCallsProvider foreignCalls, 128 HotSpotSnippetReflectionProvider snippetReflection, 129 HotSpotReplacementsImpl replacements, 130 HotSpotWordTypes wordTypes, 131 OptionValues options, 132 TargetDescription target) { 133 Plugins plugins = HotSpotGraphBuilderPlugins.create( 134 graalRuntime, 135 compilerConfiguration, 136 config, 137 wordTypes, 138 metaAccess, 139 constantReflection, 140 snippetReflection, 141 foreignCalls, 142 replacements, 143 options, 144 target); 145 SPARCGraphBuilderPlugins.register(plugins, replacements, false); 146 return plugins; 147 } 148 149 /** 150 * @param replacements 151 */ 152 protected HotSpotSuitesProvider createSuites(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, CompilerConfiguration compilerConfiguration, Plugins plugins, 153 Replacements replacements) { 154 return new AddressLoweringHotSpotSuitesProvider(new SPARCSuitesCreator(compilerConfiguration, plugins), config, runtime, new AddressLoweringPhase(new SPARCAddressLowering())); 155 } 156 157 protected SPARCHotSpotBackend createBackend(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, HotSpotProviders providers) { 158 return new SPARCHotSpotBackend(config, runtime, providers); 159 } 160 161 protected HotSpotLoweringProvider createLowerer(HotSpotGraalRuntimeProvider runtime, HotSpotMetaAccessProvider metaAccess, HotSpotForeignCallsProvider foreignCalls, 162 HotSpotRegistersProvider registers, HotSpotConstantReflectionProvider constantReflection, PlatformConfigurationProvider platformConfig, TargetDescription target) { 163 return new SPARCHotSpotLoweringProvider(runtime, metaAccess, foreignCalls, registers, constantReflection, platformConfig, target); 164 } 165 166 protected HotSpotRegistersProvider createRegisters() { 167 return new HotSpotRegisters(SPARC.g2, SPARC.g6, SPARC.sp); 168 } 169 170 @SuppressWarnings("unused") 171 private static Value[] createNativeABICallerSaveRegisters(GraalHotSpotVMConfig config, RegisterConfig regConfig) { 172 Set<Register> callerSavedRegisters = new HashSet<>(); 173 SPARC.fpusRegisters.addTo(callerSavedRegisters); 174 SPARC.fpudRegisters.addTo(callerSavedRegisters); 175 callerSavedRegisters.add(SPARC.g1); 176 callerSavedRegisters.add(SPARC.g4); 177 callerSavedRegisters.add(SPARC.g5); 178 Value[] nativeABICallerSaveRegisters = new Value[callerSavedRegisters.size()]; 179 int i = 0; 180 for (Register reg : callerSavedRegisters) { 181 nativeABICallerSaveRegisters[i] = reg.asValue(); 182 i++; 183 } 184 return nativeABICallerSaveRegisters; 185 } 186 187 @Override 188 public String toString() { 189 return "SPARC"; 190 } 191 }