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