1/* 2 * Copyright (c) 2013, 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 */ 23package org.graalvm.compiler.hotspot.meta; 24 25import static jdk.vm.ci.hotspot.HotSpotCallingConventionType.NativeCall; 26import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC; 27import static org.graalvm.compiler.core.target.Backend.ARITHMETIC_DREM; 28import static org.graalvm.compiler.core.target.Backend.ARITHMETIC_FREM; 29import static org.graalvm.compiler.hotspot.HotSpotBackend.BACKEDGE_EVENT; 30import static org.graalvm.compiler.hotspot.HotSpotBackend.DECRYPT; 31import static org.graalvm.compiler.hotspot.HotSpotBackend.DECRYPT_BLOCK; 32import static org.graalvm.compiler.hotspot.HotSpotBackend.DECRYPT_BLOCK_WITH_ORIGINAL_KEY; 33import static org.graalvm.compiler.hotspot.HotSpotBackend.DECRYPT_WITH_ORIGINAL_KEY; 34import static org.graalvm.compiler.hotspot.HotSpotBackend.ENCRYPT; 35import static org.graalvm.compiler.hotspot.HotSpotBackend.ENCRYPT_BLOCK; 36import static org.graalvm.compiler.hotspot.HotSpotBackend.EXCEPTION_HANDLER; 37import static org.graalvm.compiler.hotspot.HotSpotBackend.IC_MISS_HANDLER; 38import static org.graalvm.compiler.hotspot.HotSpotBackend.INITIALIZE_KLASS_BY_SYMBOL; 39import static org.graalvm.compiler.hotspot.HotSpotBackend.INVOCATION_EVENT; 40import static org.graalvm.compiler.hotspot.HotSpotBackend.MONTGOMERY_MULTIPLY; 41import static org.graalvm.compiler.hotspot.HotSpotBackend.MONTGOMERY_SQUARE; 42import static org.graalvm.compiler.hotspot.HotSpotBackend.MULTIPLY_TO_LEN; 43import static org.graalvm.compiler.hotspot.HotSpotBackend.MUL_ADD; 44import static org.graalvm.compiler.hotspot.HotSpotBackend.NEW_ARRAY; 45import static org.graalvm.compiler.hotspot.HotSpotBackend.NEW_INSTANCE; 46import static org.graalvm.compiler.hotspot.HotSpotBackend.NEW_MULTI_ARRAY; 47import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_KLASS_BY_SYMBOL; 48import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_METHOD_BY_SYMBOL_AND_LOAD_COUNTERS; 49import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_STRING_BY_SYMBOL; 50import static org.graalvm.compiler.hotspot.HotSpotBackend.SHA2_IMPL_COMPRESS; 51import static org.graalvm.compiler.hotspot.HotSpotBackend.SHA5_IMPL_COMPRESS; 52import static org.graalvm.compiler.hotspot.HotSpotBackend.SHA_IMPL_COMPRESS; 53import static org.graalvm.compiler.hotspot.HotSpotBackend.SQUARE_TO_LEN; 54import static org.graalvm.compiler.hotspot.HotSpotBackend.UNSAFE_ARRAYCOPY; 55import static org.graalvm.compiler.hotspot.HotSpotBackend.UNWIND_EXCEPTION_TO_CALLER; 56import static org.graalvm.compiler.hotspot.HotSpotBackend.VM_ERROR; 57import static org.graalvm.compiler.hotspot.HotSpotBackend.WRONG_METHOD_HANDLER; 58import static org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage.RegisterEffect.DESTROYS_REGISTERS; 59import static org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage.RegisterEffect.PRESERVES_REGISTERS; 60import static org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage.Transition.LEAF; 61import static org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage.Transition.LEAF_NOFP; 62import static org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage.Transition.SAFEPOINT; 63import static org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage.Transition.STACK_INSPECTABLE_LEAF; 64import static org.graalvm.compiler.hotspot.HotSpotHostBackend.DEOPTIMIZATION_HANDLER; 65import static org.graalvm.compiler.hotspot.HotSpotHostBackend.UNCOMMON_TRAP_HANDLER; 66import static org.graalvm.compiler.hotspot.meta.DefaultHotSpotLoweringProvider.RuntimeCalls.CREATE_ARRAY_STORE_EXCEPTION; 67import static org.graalvm.compiler.hotspot.meta.DefaultHotSpotLoweringProvider.RuntimeCalls.CREATE_CLASS_CAST_EXCEPTION; 68import static org.graalvm.compiler.hotspot.meta.DefaultHotSpotLoweringProvider.RuntimeCalls.CREATE_NULL_POINTER_EXCEPTION; 69import static org.graalvm.compiler.hotspot.meta.DefaultHotSpotLoweringProvider.RuntimeCalls.CREATE_OUT_OF_BOUNDS_EXCEPTION; 70import static org.graalvm.compiler.hotspot.replacements.AssertionSnippets.ASSERTION_VM_MESSAGE_C; 71import static org.graalvm.compiler.hotspot.replacements.HotSpotReplacementsUtil.MARK_WORD_LOCATION; 72import static org.graalvm.compiler.hotspot.replacements.HotSpotReplacementsUtil.TLAB_END_LOCATION; 73import static org.graalvm.compiler.hotspot.replacements.HotSpotReplacementsUtil.TLAB_TOP_LOCATION; 74import static org.graalvm.compiler.hotspot.replacements.MonitorSnippets.MONITORENTER; 75import static org.graalvm.compiler.hotspot.replacements.MonitorSnippets.MONITOREXIT; 76import static org.graalvm.compiler.hotspot.replacements.NewObjectSnippets.DYNAMIC_NEW_ARRAY; 77import static org.graalvm.compiler.hotspot.replacements.NewObjectSnippets.DYNAMIC_NEW_INSTANCE; 78import static org.graalvm.compiler.hotspot.replacements.ThreadSubstitutions.THREAD_IS_INTERRUPTED; 79import static org.graalvm.compiler.hotspot.replacements.WriteBarrierSnippets.G1WBPOSTCALL; 80import static org.graalvm.compiler.hotspot.replacements.WriteBarrierSnippets.G1WBPRECALL; 81import static org.graalvm.compiler.hotspot.replacements.WriteBarrierSnippets.VALIDATE_OBJECT; 82import static org.graalvm.compiler.hotspot.stubs.ExceptionHandlerStub.EXCEPTION_HANDLER_FOR_PC; 83import static org.graalvm.compiler.hotspot.stubs.NewArrayStub.NEW_ARRAY_C; 84import static org.graalvm.compiler.hotspot.stubs.NewInstanceStub.NEW_INSTANCE_C; 85import static org.graalvm.compiler.hotspot.stubs.StubUtil.VM_MESSAGE_C; 86import static org.graalvm.compiler.hotspot.stubs.UnwindExceptionToCallerStub.EXCEPTION_HANDLER_FOR_RETURN_ADDRESS; 87import static org.graalvm.compiler.nodes.NamedLocationIdentity.any; 88import static org.graalvm.compiler.nodes.java.ForeignCallDescriptors.REGISTER_FINALIZER; 89import static org.graalvm.compiler.replacements.Log.LOG_OBJECT; 90import static org.graalvm.compiler.replacements.Log.LOG_PRIMITIVE; 91import static org.graalvm.compiler.replacements.Log.LOG_PRINTF; 92import static org.graalvm.compiler.replacements.nodes.BinaryMathIntrinsicNode.BinaryOperation.POW; 93import static org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation.COS; 94import static org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation.EXP; 95import static org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation.LOG; 96import static org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation.LOG10; 97import static org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation.SIN; 98import static org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation.TAN; 99 100import java.util.EnumMap; 101 102import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor; 103import org.graalvm.compiler.core.common.spi.ForeignCallsProvider; 104import org.graalvm.compiler.debug.GraalError; 105import org.graalvm.compiler.hotspot.CompilerRuntimeHotSpotVMConfig; 106import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig; 107import org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage; 108import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider; 109import org.graalvm.compiler.hotspot.stubs.ArrayStoreExceptionStub; 110import org.graalvm.compiler.hotspot.stubs.ClassCastExceptionStub; 111import org.graalvm.compiler.hotspot.stubs.CreateExceptionStub; 112import org.graalvm.compiler.hotspot.stubs.ExceptionHandlerStub; 113import org.graalvm.compiler.hotspot.stubs.NewArrayStub; 114import org.graalvm.compiler.hotspot.stubs.NewInstanceStub; 115import org.graalvm.compiler.hotspot.stubs.NullPointerExceptionStub; 116import org.graalvm.compiler.hotspot.stubs.OutOfBoundsExceptionStub; 117import org.graalvm.compiler.hotspot.stubs.Stub; 118import org.graalvm.compiler.hotspot.stubs.UnwindExceptionToCallerStub; 119import org.graalvm.compiler.hotspot.stubs.VerifyOopStub; 120import org.graalvm.compiler.nodes.NamedLocationIdentity; 121import org.graalvm.compiler.options.OptionValues; 122import org.graalvm.compiler.word.Word; 123import org.graalvm.compiler.word.WordTypes; 124import org.graalvm.util.EconomicMap; 125import org.graalvm.word.LocationIdentity; 126 127import jdk.vm.ci.code.CodeCacheProvider; 128import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime; 129import jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider; 130import jdk.vm.ci.meta.JavaKind; 131import jdk.vm.ci.meta.MetaAccessProvider; 132 133/** 134 * HotSpot implementation of {@link ForeignCallsProvider}. 135 */ 136public abstract class HotSpotHostForeignCallsProvider extends HotSpotForeignCallsProviderImpl { 137 138 public static final ForeignCallDescriptor JAVA_TIME_MILLIS = new ForeignCallDescriptor("javaTimeMillis", long.class); 139 public static final ForeignCallDescriptor JAVA_TIME_NANOS = new ForeignCallDescriptor("javaTimeNanos", long.class); 140 141 public HotSpotHostForeignCallsProvider(HotSpotJVMCIRuntimeProvider jvmciRuntime, HotSpotGraalRuntimeProvider runtime, MetaAccessProvider metaAccess, CodeCacheProvider codeCache, 142 WordTypes wordTypes) { 143 super(jvmciRuntime, runtime, metaAccess, codeCache, wordTypes); 144 } 145 146 protected static void link(Stub stub) { 147 stub.getLinkage().setCompiledStub(stub); 148 } 149 150 public static ForeignCallDescriptor lookupCheckcastArraycopyDescriptor(boolean uninit) { 151 return checkcastArraycopyDescriptors[uninit ? 1 : 0]; 152 } 153 154 public static ForeignCallDescriptor lookupArraycopyDescriptor(JavaKind kind, boolean aligned, boolean disjoint, boolean uninit, boolean killAny) { 155 if (uninit) { 156 assert kind == JavaKind.Object; 157 assert !killAny : "unsupported"; 158 return uninitObjectArraycopyDescriptors[aligned ? 1 : 0][disjoint ? 1 : 0]; 159 } 160 if (killAny) { 161 assert kind == JavaKind.Object; 162 return objectArraycopyDescriptorsKillAny[aligned ? 1 : 0][disjoint ? 1 : 0]; 163 } 164 return arraycopyDescriptors[aligned ? 1 : 0][disjoint ? 1 : 0].get(kind); 165 } 166 167 @SuppressWarnings({"unchecked"}) private static final EnumMap<JavaKind, ForeignCallDescriptor>[][] arraycopyDescriptors = (EnumMap<JavaKind, ForeignCallDescriptor>[][]) new EnumMap<?, ?>[2][2]; 168 169 private static final ForeignCallDescriptor[][] uninitObjectArraycopyDescriptors = new ForeignCallDescriptor[2][2]; 170 private static final ForeignCallDescriptor[] checkcastArraycopyDescriptors = new ForeignCallDescriptor[2]; 171 private static ForeignCallDescriptor[][] objectArraycopyDescriptorsKillAny = new ForeignCallDescriptor[2][2]; 172 173 static { 174 // Populate the EnumMap instances 175 for (int i = 0; i < arraycopyDescriptors.length; i++) { 176 for (int j = 0; j < arraycopyDescriptors[i].length; j++) { 177 arraycopyDescriptors[i][j] = new EnumMap<>(JavaKind.class); 178 } 179 } 180 } 181 182 private void registerArraycopyDescriptor(EconomicMap<Long, ForeignCallDescriptor> descMap, JavaKind kind, boolean aligned, boolean disjoint, boolean uninit, boolean killAny, long routine) { 183 ForeignCallDescriptor desc = descMap.get(routine); 184 if (desc == null) { 185 desc = buildDescriptor(kind, aligned, disjoint, uninit, killAny, routine); 186 descMap.put(routine, desc); 187 } 188 if (uninit) { 189 assert kind == JavaKind.Object; 190 uninitObjectArraycopyDescriptors[aligned ? 1 : 0][disjoint ? 1 : 0] = desc; 191 } else { 192 arraycopyDescriptors[aligned ? 1 : 0][disjoint ? 1 : 0].put(kind, desc); 193 } 194 } 195 196 private ForeignCallDescriptor buildDescriptor(JavaKind kind, boolean aligned, boolean disjoint, boolean uninit, boolean killAny, long routine) { 197 assert !killAny || kind == JavaKind.Object; 198 String name = kind + (aligned ? "Aligned" : "") + (disjoint ? "Disjoint" : "") + (uninit ? "Uninit" : "") + "Arraycopy" + (killAny ? "KillAny" : ""); 199 ForeignCallDescriptor desc = new ForeignCallDescriptor(name, void.class, Word.class, Word.class, Word.class); 200 LocationIdentity killed = killAny ? LocationIdentity.any() : NamedLocationIdentity.getArrayLocation(kind); 201 registerForeignCall(desc, routine, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, killed); 202 return desc; 203 } 204 205 private void registerCheckcastArraycopyDescriptor(boolean uninit, long routine) { 206 String name = "Object" + (uninit ? "Uninit" : "") + "Checkcast"; 207 // Input: 208 // c_rarg0 - source array address 209 // c_rarg1 - destination array address 210 // c_rarg2 - element count, treated as ssize_t, can be zero 211 // c_rarg3 - size_t ckoff (super_check_offset) 212 // c_rarg4 - oop ckval (super_klass) 213 // return: 0 = success, n = number of copied elements xor'd with -1. 214 ForeignCallDescriptor desc = new ForeignCallDescriptor(name, int.class, Word.class, Word.class, Word.class, Word.class, Word.class); 215 LocationIdentity killed = NamedLocationIdentity.getArrayLocation(JavaKind.Object); 216 registerForeignCall(desc, routine, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, killed); 217 checkcastArraycopyDescriptors[uninit ? 1 : 0] = desc; 218 } 219 220 private void registerArrayCopy(JavaKind kind, long routine, long alignedRoutine, long disjointRoutine, long alignedDisjointRoutine) { 221 registerArrayCopy(kind, routine, alignedRoutine, disjointRoutine, alignedDisjointRoutine, false); 222 } 223 224 private void registerArrayCopy(JavaKind kind, long routine, long alignedRoutine, long disjointRoutine, long alignedDisjointRoutine, boolean uninit) { 225 /* 226 * Sometimes the same function is used for multiple cases so share them when that's the case 227 * but only within the same Kind. For instance short and char are the same copy routines but 228 * they kill different memory so they still have to be distinct. 229 */ 230 EconomicMap<Long, ForeignCallDescriptor> descMap = EconomicMap.create(); 231 registerArraycopyDescriptor(descMap, kind, false, false, uninit, false, routine); 232 registerArraycopyDescriptor(descMap, kind, true, false, uninit, false, alignedRoutine); 233 registerArraycopyDescriptor(descMap, kind, false, true, uninit, false, disjointRoutine); 234 registerArraycopyDescriptor(descMap, kind, true, true, uninit, false, alignedDisjointRoutine); 235 236 if (kind == JavaKind.Object && !uninit) { 237 objectArraycopyDescriptorsKillAny[0][0] = buildDescriptor(kind, false, false, uninit, true, routine); 238 objectArraycopyDescriptorsKillAny[1][0] = buildDescriptor(kind, true, false, uninit, true, alignedRoutine); 239 objectArraycopyDescriptorsKillAny[0][1] = buildDescriptor(kind, false, true, uninit, true, disjointRoutine); 240 objectArraycopyDescriptorsKillAny[1][1] = buildDescriptor(kind, true, true, uninit, true, alignedDisjointRoutine); 241 } 242 } 243 244 public void initialize(HotSpotProviders providers, OptionValues options) { 245 GraalHotSpotVMConfig c = runtime.getVMConfig(); 246 registerForeignCall(DEOPTIMIZATION_HANDLER, c.handleDeoptStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 247 registerForeignCall(UNCOMMON_TRAP_HANDLER, c.uncommonTrapStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 248 registerForeignCall(IC_MISS_HANDLER, c.inlineCacheMissStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 249 250 registerForeignCall(JAVA_TIME_MILLIS, c.javaTimeMillisAddress, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 251 registerForeignCall(JAVA_TIME_NANOS, c.javaTimeNanosAddress, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 252 registerForeignCall(SIN.foreignCallDescriptor, c.arithmeticSinAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 253 registerForeignCall(COS.foreignCallDescriptor, c.arithmeticCosAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 254 registerForeignCall(TAN.foreignCallDescriptor, c.arithmeticTanAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 255 registerForeignCall(EXP.foreignCallDescriptor, c.arithmeticExpAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 256 registerForeignCall(LOG.foreignCallDescriptor, c.arithmeticLogAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 257 registerForeignCall(LOG10.foreignCallDescriptor, c.arithmeticLog10Address, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 258 registerForeignCall(POW.foreignCallDescriptor, c.arithmeticPowAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 259 registerForeignCall(ARITHMETIC_FREM, c.fremAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 260 registerForeignCall(ARITHMETIC_DREM, c.dremAddress, NativeCall, DESTROYS_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 261 262 registerForeignCall(LOAD_AND_CLEAR_EXCEPTION, c.loadAndClearExceptionAddress, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, any()); 263 264 registerForeignCall(EXCEPTION_HANDLER_FOR_PC, c.exceptionHandlerForPcAddress, NativeCall, DESTROYS_REGISTERS, SAFEPOINT, REEXECUTABLE, any()); 265 registerForeignCall(EXCEPTION_HANDLER_FOR_RETURN_ADDRESS, c.exceptionHandlerForReturnAddressAddress, NativeCall, DESTROYS_REGISTERS, SAFEPOINT, REEXECUTABLE, any()); 266 registerForeignCall(NEW_ARRAY_C, c.newArrayAddress, NativeCall, DESTROYS_REGISTERS, SAFEPOINT, REEXECUTABLE, any()); 267 registerForeignCall(NEW_INSTANCE_C, c.newInstanceAddress, NativeCall, DESTROYS_REGISTERS, SAFEPOINT, REEXECUTABLE, any()); 268 269 CreateExceptionStub.registerForeignCalls(c, this); 270 271 /* 272 * This message call is registered twice, where the second one must only be used for calls 273 * that do not return, i.e., that exit the VM. 274 */ 275 registerForeignCall(VM_MESSAGE_C, c.vmMessageAddress, NativeCall, DESTROYS_REGISTERS, SAFEPOINT, REEXECUTABLE, NO_LOCATIONS); 276 registerForeignCall(ASSERTION_VM_MESSAGE_C, c.vmMessageAddress, NativeCall, PRESERVES_REGISTERS, LEAF, REEXECUTABLE, NO_LOCATIONS); 277 278 link(new NewInstanceStub(options, providers, registerStubCall(NEW_INSTANCE, REEXECUTABLE, SAFEPOINT, TLAB_TOP_LOCATION, TLAB_END_LOCATION))); 279 link(new NewArrayStub(options, providers, registerStubCall(NEW_ARRAY, REEXECUTABLE, SAFEPOINT, TLAB_TOP_LOCATION, TLAB_END_LOCATION))); 280 link(new ExceptionHandlerStub(options, providers, foreignCalls.get(EXCEPTION_HANDLER))); 281 link(new UnwindExceptionToCallerStub(options, providers, registerStubCall(UNWIND_EXCEPTION_TO_CALLER, NOT_REEXECUTABLE, SAFEPOINT, any()))); 282 link(new VerifyOopStub(options, providers, registerStubCall(VERIFY_OOP, REEXECUTABLE, LEAF_NOFP, NO_LOCATIONS))); 283 link(new ArrayStoreExceptionStub(options, providers, registerStubCall(CREATE_ARRAY_STORE_EXCEPTION, REEXECUTABLE, SAFEPOINT, any()))); 284 link(new ClassCastExceptionStub(options, providers, registerStubCall(CREATE_CLASS_CAST_EXCEPTION, REEXECUTABLE, SAFEPOINT, any()))); 285 link(new NullPointerExceptionStub(options, providers, registerStubCall(CREATE_NULL_POINTER_EXCEPTION, REEXECUTABLE, SAFEPOINT, any()))); 286 link(new OutOfBoundsExceptionStub(options, providers, registerStubCall(CREATE_OUT_OF_BOUNDS_EXCEPTION, REEXECUTABLE, SAFEPOINT, any()))); 287 288 linkForeignCall(options, providers, IDENTITY_HASHCODE, c.identityHashCodeAddress, PREPEND_THREAD, SAFEPOINT, NOT_REEXECUTABLE, MARK_WORD_LOCATION); 289 linkForeignCall(options, providers, REGISTER_FINALIZER, c.registerFinalizerAddress, PREPEND_THREAD, SAFEPOINT, NOT_REEXECUTABLE, any()); 290 linkForeignCall(options, providers, MONITORENTER, c.monitorenterAddress, PREPEND_THREAD, SAFEPOINT, NOT_REEXECUTABLE, any()); 291 linkForeignCall(options, providers, MONITOREXIT, c.monitorexitAddress, PREPEND_THREAD, STACK_INSPECTABLE_LEAF, NOT_REEXECUTABLE, any()); 292 linkForeignCall(options, providers, NEW_MULTI_ARRAY, c.newMultiArrayAddress, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, TLAB_TOP_LOCATION, TLAB_END_LOCATION); 293 linkForeignCall(options, providers, DYNAMIC_NEW_ARRAY, c.dynamicNewArrayAddress, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE); 294 linkForeignCall(options, providers, DYNAMIC_NEW_INSTANCE, c.dynamicNewInstanceAddress, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE); 295 linkForeignCall(options, providers, LOG_PRINTF, c.logPrintfAddress, PREPEND_THREAD, LEAF, REEXECUTABLE, NO_LOCATIONS); 296 linkForeignCall(options, providers, LOG_OBJECT, c.logObjectAddress, PREPEND_THREAD, LEAF, REEXECUTABLE, NO_LOCATIONS); 297 linkForeignCall(options, providers, LOG_PRIMITIVE, c.logPrimitiveAddress, PREPEND_THREAD, LEAF, REEXECUTABLE, NO_LOCATIONS); 298 linkForeignCall(options, providers, VM_ERROR, c.vmErrorAddress, PREPEND_THREAD, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 299 linkForeignCall(options, providers, OSR_MIGRATION_END, c.osrMigrationEndAddress, DONT_PREPEND_THREAD, LEAF_NOFP, NOT_REEXECUTABLE, NO_LOCATIONS); 300 linkForeignCall(options, providers, G1WBPRECALL, c.writeBarrierPreAddress, PREPEND_THREAD, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 301 linkForeignCall(options, providers, G1WBPOSTCALL, c.writeBarrierPostAddress, PREPEND_THREAD, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 302 linkForeignCall(options, providers, VALIDATE_OBJECT, c.validateObject, PREPEND_THREAD, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 303 304 if (GeneratePIC.getValue(options)) { 305 registerForeignCall(WRONG_METHOD_HANDLER, c.handleWrongMethodStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, REEXECUTABLE, NO_LOCATIONS); 306 CompilerRuntimeHotSpotVMConfig cr = new CompilerRuntimeHotSpotVMConfig(HotSpotJVMCIRuntime.runtime().getConfigStore()); 307 linkForeignCall(options, providers, RESOLVE_STRING_BY_SYMBOL, cr.resolveStringBySymbol, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, TLAB_TOP_LOCATION, TLAB_END_LOCATION); 308 linkForeignCall(options, providers, RESOLVE_KLASS_BY_SYMBOL, cr.resolveKlassBySymbol, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, any()); 309 linkForeignCall(options, providers, RESOLVE_METHOD_BY_SYMBOL_AND_LOAD_COUNTERS, cr.resolveMethodBySymbolAndLoadCounters, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, NO_LOCATIONS); 310 linkForeignCall(options, providers, INITIALIZE_KLASS_BY_SYMBOL, cr.initializeKlassBySymbol, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, any()); 311 linkForeignCall(options, providers, INVOCATION_EVENT, cr.invocationEvent, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, NO_LOCATIONS); 312 linkForeignCall(options, providers, BACKEDGE_EVENT, cr.backedgeEvent, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, NO_LOCATIONS); 313 } 314 315 // Cannot be a leaf as VM acquires Thread_lock which requires thread_in_vm state 316 linkForeignCall(options, providers, THREAD_IS_INTERRUPTED, c.threadIsInterruptedAddress, PREPEND_THREAD, SAFEPOINT, NOT_REEXECUTABLE, any()); 317 318 linkForeignCall(options, providers, TEST_DEOPTIMIZE_CALL_INT, c.testDeoptimizeCallInt, PREPEND_THREAD, SAFEPOINT, REEXECUTABLE, any()); 319 320 registerArrayCopy(JavaKind.Byte, c.jbyteArraycopy, c.jbyteAlignedArraycopy, c.jbyteDisjointArraycopy, c.jbyteAlignedDisjointArraycopy); 321 registerArrayCopy(JavaKind.Boolean, c.jbyteArraycopy, c.jbyteAlignedArraycopy, c.jbyteDisjointArraycopy, c.jbyteAlignedDisjointArraycopy); 322 registerArrayCopy(JavaKind.Char, c.jshortArraycopy, c.jshortAlignedArraycopy, c.jshortDisjointArraycopy, c.jshortAlignedDisjointArraycopy); 323 registerArrayCopy(JavaKind.Short, c.jshortArraycopy, c.jshortAlignedArraycopy, c.jshortDisjointArraycopy, c.jshortAlignedDisjointArraycopy); 324 registerArrayCopy(JavaKind.Int, c.jintArraycopy, c.jintAlignedArraycopy, c.jintDisjointArraycopy, c.jintAlignedDisjointArraycopy); 325 registerArrayCopy(JavaKind.Float, c.jintArraycopy, c.jintAlignedArraycopy, c.jintDisjointArraycopy, c.jintAlignedDisjointArraycopy); 326 registerArrayCopy(JavaKind.Long, c.jlongArraycopy, c.jlongAlignedArraycopy, c.jlongDisjointArraycopy, c.jlongAlignedDisjointArraycopy); 327 registerArrayCopy(JavaKind.Double, c.jlongArraycopy, c.jlongAlignedArraycopy, c.jlongDisjointArraycopy, c.jlongAlignedDisjointArraycopy); 328 registerArrayCopy(JavaKind.Object, c.oopArraycopy, c.oopAlignedArraycopy, c.oopDisjointArraycopy, c.oopAlignedDisjointArraycopy); 329 registerArrayCopy(JavaKind.Object, c.oopArraycopyUninit, c.oopAlignedArraycopyUninit, c.oopDisjointArraycopyUninit, c.oopAlignedDisjointArraycopyUninit, true); 330 331 registerCheckcastArraycopyDescriptor(true, c.checkcastArraycopyUninit); 332 registerCheckcastArraycopyDescriptor(false, c.checkcastArraycopy); 333 334 registerForeignCall(UNSAFE_ARRAYCOPY, c.unsafeArraycopy, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.any()); 335 336 if (c.useMultiplyToLenIntrinsic()) { 337 registerForeignCall(MULTIPLY_TO_LEN, c.multiplyToLen, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Int)); 338 } 339 if (c.useSHA1Intrinsics()) { 340 registerForeignCall(SHA_IMPL_COMPRESS, c.sha1ImplCompress, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.any()); 341 } 342 if (c.useSHA256Intrinsics()) { 343 registerForeignCall(SHA2_IMPL_COMPRESS, c.sha256ImplCompress, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.any()); 344 } 345 if (c.useSHA512Intrinsics()) { 346 registerForeignCall(SHA5_IMPL_COMPRESS, c.sha512ImplCompress, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.any()); 347 } 348 if (c.useMulAddIntrinsic()) { 349 registerForeignCall(MUL_ADD, c.mulAdd, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Int)); 350 } 351 if (c.useMontgomeryMultiplyIntrinsic()) { 352 registerForeignCall(MONTGOMERY_MULTIPLY, c.montgomeryMultiply, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Int)); 353 } 354 if (c.useMontgomerySquareIntrinsic()) { 355 registerForeignCall(MONTGOMERY_SQUARE, c.montgomerySquare, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Int)); 356 } 357 if (c.useSquareToLenIntrinsic()) { 358 registerForeignCall(SQUARE_TO_LEN, c.squareToLen, NativeCall, DESTROYS_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Int)); 359 } 360 361 if (c.useAESIntrinsics) { 362 /* 363 * When the java.ext.dirs property is modified then the crypto classes might not be 364 * found. If that's the case we ignore the ClassNotFoundException and continue since we 365 * cannot replace a non-existing method anyway. 366 */ 367 try { 368 // These stubs do callee saving 369 registerForeignCall(ENCRYPT_BLOCK, c.aescryptEncryptBlockStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Byte)); 370 registerForeignCall(DECRYPT_BLOCK, c.aescryptDecryptBlockStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, NamedLocationIdentity.getArrayLocation(JavaKind.Byte)); 371 registerForeignCall(DECRYPT_BLOCK_WITH_ORIGINAL_KEY, c.aescryptDecryptBlockStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, 372 NamedLocationIdentity.getArrayLocation(JavaKind.Byte)); 373 } catch (GraalError e) { 374 if (!(e.getCause() instanceof ClassNotFoundException)) { 375 throw e; 376 } 377 } 378 try { 379 // These stubs do callee saving 380 registerForeignCall(ENCRYPT, c.cipherBlockChainingEncryptAESCryptStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, 381 NamedLocationIdentity.getArrayLocation(JavaKind.Byte)); 382 registerForeignCall(DECRYPT, c.cipherBlockChainingDecryptAESCryptStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, 383 NamedLocationIdentity.getArrayLocation(JavaKind.Byte)); 384 registerForeignCall(DECRYPT_WITH_ORIGINAL_KEY, c.cipherBlockChainingDecryptAESCryptStub, NativeCall, PRESERVES_REGISTERS, LEAF_NOFP, NOT_REEXECUTABLE, 385 NamedLocationIdentity.getArrayLocation(JavaKind.Byte)); 386 } catch (GraalError e) { 387 if (!(e.getCause() instanceof ClassNotFoundException)) { 388 throw e; 389 } 390 } 391 } 392 } 393 394 public HotSpotForeignCallLinkage getForeignCall(ForeignCallDescriptor descriptor) { 395 assert foreignCalls != null : descriptor; 396 return foreignCalls.get(descriptor); 397 } 398} 399