HotSpotGraphBuilderPlugins.java revision 12651:6ef01bd40ce2
1/* 2 * Copyright (c) 2015, 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 org.graalvm.compiler.core.common.util.Util.Java8OrEarlier; 26import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC; 27import static org.graalvm.compiler.hotspot.meta.HotSpotAOTProfilingPlugin.Options.TieredAOT; 28import static org.graalvm.compiler.hotspot.replacements.HotSpotReplacementsUtil.JAVA_THREAD_THREAD_OBJECT_LOCATION; 29import static org.graalvm.compiler.java.BytecodeParserOptions.InlineDuringParsing; 30 31import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateRecompile; 32import static jdk.vm.ci.meta.DeoptimizationReason.Unresolved; 33 34import java.lang.invoke.ConstantCallSite; 35import java.lang.invoke.MutableCallSite; 36import java.lang.invoke.VolatileCallSite; 37import java.lang.reflect.Method; 38import java.lang.reflect.Modifier; 39import java.math.BigInteger; 40import java.util.zip.CRC32; 41 42import org.graalvm.compiler.api.replacements.SnippetReflectionProvider; 43import org.graalvm.compiler.bytecode.BytecodeProvider; 44import org.graalvm.compiler.core.common.LocationIdentity; 45import org.graalvm.compiler.core.common.spi.ForeignCallsProvider; 46import org.graalvm.compiler.debug.GraalError; 47import org.graalvm.compiler.hotspot.FingerprintUtil; 48import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig; 49import org.graalvm.compiler.hotspot.nodes.CurrentJavaThreadNode; 50import org.graalvm.compiler.hotspot.replacements.AESCryptSubstitutions; 51import org.graalvm.compiler.hotspot.replacements.BigIntegerSubstitutions; 52import org.graalvm.compiler.hotspot.replacements.CRC32Substitutions; 53import org.graalvm.compiler.hotspot.replacements.CallSiteTargetNode; 54import org.graalvm.compiler.hotspot.replacements.CipherBlockChainingSubstitutions; 55import org.graalvm.compiler.hotspot.replacements.ClassGetHubNode; 56import org.graalvm.compiler.hotspot.replacements.IdentityHashCodeNode; 57import org.graalvm.compiler.hotspot.replacements.HotSpotClassSubstitutions; 58import org.graalvm.compiler.hotspot.replacements.ObjectCloneNode; 59import org.graalvm.compiler.hotspot.replacements.ObjectSubstitutions; 60import org.graalvm.compiler.hotspot.replacements.ReflectionGetCallerClassNode; 61import org.graalvm.compiler.hotspot.replacements.ReflectionSubstitutions; 62import org.graalvm.compiler.hotspot.replacements.SHA2Substitutions; 63import org.graalvm.compiler.hotspot.replacements.SHA5Substitutions; 64import org.graalvm.compiler.hotspot.replacements.SHASubstitutions; 65import org.graalvm.compiler.hotspot.replacements.ThreadSubstitutions; 66import org.graalvm.compiler.hotspot.replacements.arraycopy.ArrayCopyNode; 67import org.graalvm.compiler.hotspot.word.HotSpotWordTypes; 68import org.graalvm.compiler.nodes.ConstantNode; 69import org.graalvm.compiler.nodes.DeoptimizeNode; 70import org.graalvm.compiler.nodes.DynamicPiNode; 71import org.graalvm.compiler.nodes.FixedGuardNode; 72import org.graalvm.compiler.nodes.LogicNode; 73import org.graalvm.compiler.nodes.NamedLocationIdentity; 74import org.graalvm.compiler.nodes.PiNode; 75import org.graalvm.compiler.nodes.ValueNode; 76import org.graalvm.compiler.nodes.calc.AddNode; 77import org.graalvm.compiler.nodes.calc.LeftShiftNode; 78import org.graalvm.compiler.nodes.graphbuilderconf.ForeignCallPlugin; 79import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins; 80import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext; 81import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin; 82import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin.Receiver; 83import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins; 84import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins.Registration; 85import org.graalvm.compiler.nodes.graphbuilderconf.NodeIntrinsicPluginFactory; 86import org.graalvm.compiler.nodes.graphbuilderconf.NodePlugin; 87import org.graalvm.compiler.nodes.java.InstanceOfDynamicNode; 88import org.graalvm.compiler.nodes.memory.HeapAccess.BarrierType; 89import org.graalvm.compiler.nodes.memory.address.AddressNode; 90import org.graalvm.compiler.nodes.memory.address.OffsetAddressNode; 91import org.graalvm.compiler.nodes.spi.StampProvider; 92import org.graalvm.compiler.nodes.util.GraphUtil; 93import org.graalvm.compiler.options.StableOptionValue; 94import org.graalvm.compiler.replacements.InlineDuringParsingPlugin; 95import org.graalvm.compiler.replacements.InlineGraalDirectivesPlugin; 96import org.graalvm.compiler.replacements.MethodHandlePlugin; 97import org.graalvm.compiler.replacements.NodeIntrinsificationProvider; 98import org.graalvm.compiler.replacements.ReplacementsImpl; 99import org.graalvm.compiler.replacements.StandardGraphBuilderPlugins; 100import org.graalvm.compiler.replacements.WordOperationPlugin; 101import org.graalvm.compiler.serviceprovider.GraalServices; 102import org.graalvm.compiler.word.WordTypes; 103 104import jdk.vm.ci.code.CodeUtil; 105import jdk.vm.ci.hotspot.HotSpotObjectConstant; 106import jdk.vm.ci.hotspot.HotSpotResolvedJavaType; 107import jdk.vm.ci.hotspot.HotSpotResolvedObjectType; 108import jdk.vm.ci.meta.ConstantReflectionProvider; 109import jdk.vm.ci.meta.DeoptimizationAction; 110import jdk.vm.ci.meta.DeoptimizationReason; 111import jdk.vm.ci.meta.JavaConstant; 112import jdk.vm.ci.meta.JavaKind; 113import jdk.vm.ci.meta.MetaAccessProvider; 114import jdk.vm.ci.meta.ResolvedJavaMethod; 115 116/** 117 * Defines the {@link Plugins} used when running on HotSpot. 118 */ 119public class HotSpotGraphBuilderPlugins { 120 121 /** 122 * Creates a {@link Plugins} object that should be used when running on HotSpot. 123 * 124 * @param constantReflection 125 * @param snippetReflection 126 * @param foreignCalls 127 * @param stampProvider 128 */ 129 public static Plugins create(GraalHotSpotVMConfig config, HotSpotWordTypes wordTypes, MetaAccessProvider metaAccess, ConstantReflectionProvider constantReflection, 130 SnippetReflectionProvider snippetReflection, ForeignCallsProvider foreignCalls, StampProvider stampProvider, ReplacementsImpl replacements) { 131 InvocationPlugins invocationPlugins = new HotSpotInvocationPlugins(config, metaAccess); 132 133 Plugins plugins = new Plugins(invocationPlugins); 134 NodeIntrinsificationProvider nodeIntrinsificationProvider = new NodeIntrinsificationProvider(metaAccess, snippetReflection, foreignCalls, wordTypes); 135 HotSpotWordOperationPlugin wordOperationPlugin = new HotSpotWordOperationPlugin(snippetReflection, wordTypes); 136 HotSpotNodePlugin nodePlugin = new HotSpotNodePlugin(wordOperationPlugin); 137 138 plugins.appendTypePlugin(nodePlugin); 139 plugins.appendNodePlugin(nodePlugin); 140 if (GeneratePIC.getValue()) { 141 // AOT needs to filter out bad invokes 142 plugins.prependNodePlugin(new NodePlugin() { 143 @Override 144 public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { 145 if (b.parsingIntrinsic()) { 146 return false; 147 } 148 // check if the holder has a valid fingerprint 149 if (FingerprintUtil.getFingerprint((HotSpotResolvedObjectType) method.getDeclaringClass()) == 0) { 150 // Deopt otherwise 151 b.append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); 152 return true; 153 } 154 // the last argument that may come from appendix, check if it is a supported 155 // constant type 156 if (args.length > 0) { 157 JavaConstant constant = args[args.length - 1].asJavaConstant(); 158 if (constant != null && constant instanceof HotSpotObjectConstant) { 159 HotSpotResolvedJavaType type = (HotSpotResolvedJavaType) ((HotSpotObjectConstant) constant).getType(); 160 Class<?> clazz = type.mirror(); 161 if (clazz.equals(String.class)) { 162 return false; 163 } 164 if (Class.class.isAssignableFrom(clazz) && FingerprintUtil.getFingerprint((HotSpotResolvedObjectType) type) != 0) { 165 return false; 166 } 167 b.append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); 168 return true; 169 } 170 } 171 return false; 172 } 173 }); 174 } 175 plugins.appendNodePlugin(new MethodHandlePlugin(constantReflection.getMethodHandleAccess(), true)); 176 plugins.appendInlineInvokePlugin(replacements); 177 if (InlineDuringParsing.getValue()) { 178 plugins.appendInlineInvokePlugin(new InlineDuringParsingPlugin()); 179 } 180 plugins.appendInlineInvokePlugin(new InlineGraalDirectivesPlugin()); 181 182 if (GeneratePIC.getValue()) { 183 plugins.setClassInitializationPlugin(new HotSpotClassInitializationPlugin()); 184 if (TieredAOT.getValue()) { 185 plugins.setProfilingPlugin(new HotSpotAOTProfilingPlugin()); 186 } 187 } 188 189 invocationPlugins.defer(new Runnable() { 190 191 @Override 192 public void run() { 193 BytecodeProvider replacementBytecodeProvider = replacements.getReplacementBytecodeProvider(); 194 registerObjectPlugins(invocationPlugins, replacementBytecodeProvider); 195 registerClassPlugins(plugins, config, replacementBytecodeProvider); 196 registerSystemPlugins(invocationPlugins, foreignCalls); 197 registerThreadPlugins(invocationPlugins, metaAccess, wordTypes, config, replacementBytecodeProvider); 198 registerCallSitePlugins(invocationPlugins); 199 registerReflectionPlugins(invocationPlugins, replacementBytecodeProvider); 200 registerConstantPoolPlugins(invocationPlugins, wordTypes, config, replacementBytecodeProvider); 201 registerStableOptionPlugins(invocationPlugins, snippetReflection); 202 registerAESPlugins(invocationPlugins, config, replacementBytecodeProvider); 203 registerCRC32Plugins(invocationPlugins, config, replacementBytecodeProvider); 204 registerBigIntegerPlugins(invocationPlugins, config, replacementBytecodeProvider); 205 registerSHAPlugins(invocationPlugins, config, replacementBytecodeProvider); 206 StandardGraphBuilderPlugins.registerInvocationPlugins(metaAccess, snippetReflection, invocationPlugins, replacementBytecodeProvider, true); 207 208 for (NodeIntrinsicPluginFactory factory : GraalServices.load(NodeIntrinsicPluginFactory.class)) { 209 factory.registerPlugins(invocationPlugins, nodeIntrinsificationProvider); 210 } 211 } 212 }); 213 return plugins; 214 } 215 216 private static void registerObjectPlugins(InvocationPlugins plugins, BytecodeProvider bytecodeProvider) { 217 Registration r = new Registration(plugins, Object.class, bytecodeProvider); 218 if (!GeneratePIC.getValue()) { 219 // FIXME: clone() requires speculation and requires a fix in here (to check that 220 // b.getAssumptions() != null), and in ReplacementImpl.getSubstitution() where there is 221 // an instantiation of IntrinsicGraphBuilder using a constructor that sets 222 // AllowAssumptions to YES automatically. The former has to inherit the assumptions 223 // settings from the root compile instead. So, for now, I'm disabling it for 224 // GeneratePIC. 225 r.register1("clone", Receiver.class, new InvocationPlugin() { 226 @Override 227 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 228 ValueNode object = receiver.get(); 229 b.addPush(JavaKind.Object, new ObjectCloneNode(b.getInvokeKind(), targetMethod, b.bci(), b.getInvokeReturnStamp(b.getAssumptions()), object)); 230 return true; 231 } 232 233 @Override 234 public boolean inlineOnly() { 235 return true; 236 } 237 }); 238 } 239 r.registerMethodSubstitution(ObjectSubstitutions.class, "hashCode", Receiver.class); 240 } 241 242 private static void registerClassPlugins(Plugins plugins, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 243 Registration r = new Registration(plugins.getInvocationPlugins(), Class.class, bytecodeProvider); 244 245 r.registerMethodSubstitution(HotSpotClassSubstitutions.class, "getModifiers", Receiver.class); 246 r.registerMethodSubstitution(HotSpotClassSubstitutions.class, "isInterface", Receiver.class); 247 r.registerMethodSubstitution(HotSpotClassSubstitutions.class, "isArray", Receiver.class); 248 r.registerMethodSubstitution(HotSpotClassSubstitutions.class, "isPrimitive", Receiver.class); 249 r.registerMethodSubstitution(HotSpotClassSubstitutions.class, "getSuperclass", Receiver.class); 250 251 if (config.getFieldOffset("ArrayKlass::_component_mirror", Integer.class, "oop", Integer.MAX_VALUE) != Integer.MAX_VALUE) { 252 r.registerMethodSubstitution(HotSpotClassSubstitutions.class, "getComponentType", Receiver.class); 253 } 254 255 r.register2("cast", Receiver.class, Object.class, new InvocationPlugin() { 256 @Override 257 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object) { 258 ValueNode javaClass = receiver.get(); 259 LogicNode condition = b.recursiveAppend(InstanceOfDynamicNode.create(b.getAssumptions(), b.getConstantReflection(), javaClass, object, true)); 260 if (condition.isTautology()) { 261 b.addPush(JavaKind.Object, object); 262 } else { 263 FixedGuardNode fixedGuard = b.add(new FixedGuardNode(condition, DeoptimizationReason.ClassCastException, DeoptimizationAction.InvalidateReprofile, false)); 264 b.addPush(JavaKind.Object, new DynamicPiNode(object, fixedGuard, javaClass)); 265 } 266 return true; 267 } 268 269 @Override 270 public boolean inlineOnly() { 271 return true; 272 } 273 }); 274 } 275 276 private static void registerCallSitePlugins(InvocationPlugins plugins) { 277 InvocationPlugin plugin = new InvocationPlugin() { 278 @Override 279 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 280 ValueNode callSite = receiver.get(); 281 ValueNode folded = CallSiteTargetNode.tryFold(GraphUtil.originalValue(callSite), b.getMetaAccess(), b.getAssumptions()); 282 if (folded != null) { 283 b.addPush(JavaKind.Object, folded); 284 } else { 285 b.addPush(JavaKind.Object, new CallSiteTargetNode(b.getInvokeKind(), targetMethod, b.bci(), b.getInvokeReturnStamp(b.getAssumptions()), callSite)); 286 } 287 return true; 288 } 289 290 @Override 291 public boolean inlineOnly() { 292 return true; 293 } 294 }; 295 plugins.register(plugin, ConstantCallSite.class, "getTarget", Receiver.class); 296 plugins.register(plugin, MutableCallSite.class, "getTarget", Receiver.class); 297 plugins.register(plugin, VolatileCallSite.class, "getTarget", Receiver.class); 298 } 299 300 private static void registerReflectionPlugins(InvocationPlugins plugins, BytecodeProvider bytecodeProvider) { 301 Registration r = new Registration(plugins, reflectionClass, bytecodeProvider); 302 r.register0("getCallerClass", new InvocationPlugin() { 303 @Override 304 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 305 b.addPush(JavaKind.Object, new ReflectionGetCallerClassNode(b.getInvokeKind(), targetMethod, b.bci(), b.getInvokeReturnStamp(b.getAssumptions()))); 306 return true; 307 } 308 309 @Override 310 public boolean inlineOnly() { 311 return true; 312 } 313 }); 314 r.registerMethodSubstitution(ReflectionSubstitutions.class, "getClassAccessFlags", Class.class); 315 } 316 317 private static final LocationIdentity INSTANCE_KLASS_CONSTANTS = NamedLocationIdentity.immutable("InstanceKlass::_constants"); 318 private static final LocationIdentity CONSTANT_POOL_LENGTH = NamedLocationIdentity.immutable("ConstantPool::_length"); 319 320 /** 321 * Emits a node to get the metaspace {@code ConstantPool} pointer given the value of the 322 * {@code constantPoolOop} field in a ConstantPool value. 323 * 324 * @param constantPoolOop value of the {@code constantPoolOop} field in a ConstantPool value 325 * @return a node representing the metaspace {@code ConstantPool} pointer associated with 326 * {@code constantPoolOop} 327 */ 328 private static ValueNode getMetaspaceConstantPool(GraphBuilderContext b, ValueNode constantPoolOop, WordTypes wordTypes, GraalHotSpotVMConfig config) { 329 // ConstantPool.constantPoolOop is in fact the holder class. 330 ClassGetHubNode klass = b.add(new ClassGetHubNode(constantPoolOop)); 331 332 boolean notCompressible = false; 333 AddressNode constantsAddress = b.add(new OffsetAddressNode(klass, b.add(ConstantNode.forLong(config.instanceKlassConstantsOffset)))); 334 return WordOperationPlugin.readOp(b, wordTypes.getWordKind(), constantsAddress, INSTANCE_KLASS_CONSTANTS, BarrierType.NONE, notCompressible); 335 } 336 337 /** 338 * Emits a node representing an element in a metaspace {@code ConstantPool}. 339 * 340 * @param constantPoolOop value of the {@code constantPoolOop} field in a ConstantPool value 341 */ 342 private static boolean readMetaspaceConstantPoolElement(GraphBuilderContext b, ValueNode constantPoolOop, ValueNode index, JavaKind elementKind, WordTypes wordTypes, GraalHotSpotVMConfig config) { 343 ValueNode constants = getMetaspaceConstantPool(b, constantPoolOop, wordTypes, config); 344 int shift = CodeUtil.log2(wordTypes.getWordKind().getByteCount()); 345 ValueNode scaledIndex = b.add(new LeftShiftNode(index, b.add(ConstantNode.forInt(shift)))); 346 ValueNode offset = b.add(new AddNode(scaledIndex, b.add(ConstantNode.forInt(config.constantPoolSize)))); 347 AddressNode elementAddress = b.add(new OffsetAddressNode(constants, offset)); 348 boolean notCompressible = false; 349 ValueNode elementValue = WordOperationPlugin.readOp(b, elementKind, elementAddress, NamedLocationIdentity.getArrayLocation(elementKind), BarrierType.NONE, notCompressible); 350 b.addPush(elementKind, elementValue); 351 return true; 352 } 353 354 private static void registerConstantPoolPlugins(InvocationPlugins plugins, WordTypes wordTypes, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 355 Registration r = new Registration(plugins, constantPoolClass, bytecodeProvider); 356 357 r.register2("getSize0", Receiver.class, Object.class, new InvocationPlugin() { 358 @Override 359 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode constantPoolOop) { 360 boolean notCompressible = false; 361 ValueNode constants = getMetaspaceConstantPool(b, constantPoolOop, wordTypes, config); 362 AddressNode lengthAddress = b.add(new OffsetAddressNode(constants, b.add(ConstantNode.forLong(config.constantPoolLengthOffset)))); 363 ValueNode length = WordOperationPlugin.readOp(b, JavaKind.Int, lengthAddress, CONSTANT_POOL_LENGTH, BarrierType.NONE, notCompressible); 364 b.addPush(JavaKind.Int, length); 365 return true; 366 } 367 }); 368 369 r.register3("getIntAt0", Receiver.class, Object.class, int.class, new InvocationPlugin() { 370 @Override 371 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode constantPoolOop, ValueNode index) { 372 return readMetaspaceConstantPoolElement(b, constantPoolOop, index, JavaKind.Int, wordTypes, config); 373 } 374 }); 375 r.register3("getLongAt0", Receiver.class, Object.class, int.class, new InvocationPlugin() { 376 @Override 377 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode constantPoolOop, ValueNode index) { 378 return readMetaspaceConstantPoolElement(b, constantPoolOop, index, JavaKind.Long, wordTypes, config); 379 } 380 }); 381 r.register3("getFloatAt0", Receiver.class, Object.class, int.class, new InvocationPlugin() { 382 @Override 383 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode constantPoolOop, ValueNode index) { 384 return readMetaspaceConstantPoolElement(b, constantPoolOop, index, JavaKind.Float, wordTypes, config); 385 } 386 }); 387 r.register3("getDoubleAt0", Receiver.class, Object.class, int.class, new InvocationPlugin() { 388 @Override 389 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode constantPoolOop, ValueNode index) { 390 return readMetaspaceConstantPoolElement(b, constantPoolOop, index, JavaKind.Double, wordTypes, config); 391 } 392 }); 393 } 394 395 private static void registerSystemPlugins(InvocationPlugins plugins, ForeignCallsProvider foreignCalls) { 396 Registration r = new Registration(plugins, System.class); 397 r.register0("currentTimeMillis", new ForeignCallPlugin(foreignCalls, HotSpotHostForeignCallsProvider.JAVA_TIME_MILLIS)); 398 r.register0("nanoTime", new ForeignCallPlugin(foreignCalls, HotSpotHostForeignCallsProvider.JAVA_TIME_NANOS)); 399 r.register1("identityHashCode", Object.class, new InvocationPlugin() { 400 @Override 401 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object) { 402 b.addPush(JavaKind.Int, new IdentityHashCodeNode(object)); 403 return true; 404 } 405 406 @Override 407 public boolean inlineOnly() { 408 return true; 409 } 410 }); 411 r.register5("arraycopy", Object.class, int.class, Object.class, int.class, int.class, new InvocationPlugin() { 412 @Override 413 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode src, ValueNode srcPos, ValueNode dst, ValueNode dstPos, ValueNode length) { 414 b.add(new ArrayCopyNode(b.bci(), src, srcPos, dst, dstPos, length)); 415 return true; 416 } 417 418 @Override 419 public boolean inlineOnly() { 420 return true; 421 } 422 }); 423 } 424 425 private static void registerThreadPlugins(InvocationPlugins plugins, MetaAccessProvider metaAccess, WordTypes wordTypes, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 426 Registration r = new Registration(plugins, Thread.class, bytecodeProvider); 427 r.register0("currentThread", new InvocationPlugin() { 428 @Override 429 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 430 CurrentJavaThreadNode thread = b.add(new CurrentJavaThreadNode(wordTypes.getWordKind())); 431 boolean compressible = false; 432 ValueNode offset = b.add(ConstantNode.forLong(config.threadObjectOffset)); 433 AddressNode address = b.add(new OffsetAddressNode(thread, offset)); 434 ValueNode javaThread = WordOperationPlugin.readOp(b, JavaKind.Object, address, JAVA_THREAD_THREAD_OBJECT_LOCATION, BarrierType.NONE, compressible); 435 boolean exactType = false; 436 boolean nonNull = true; 437 b.addPush(JavaKind.Object, new PiNode(javaThread, metaAccess.lookupJavaType(Thread.class), exactType, nonNull)); 438 return true; 439 } 440 }); 441 442 r.registerMethodSubstitution(ThreadSubstitutions.class, "isInterrupted", Receiver.class, boolean.class); 443 } 444 445 private static void registerStableOptionPlugins(InvocationPlugins plugins, SnippetReflectionProvider snippetReflection) { 446 Registration r = new Registration(plugins, StableOptionValue.class); 447 r.register1("getValue", Receiver.class, new InvocationPlugin() { 448 @Override 449 public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) { 450 if (receiver.isConstant()) { 451 StableOptionValue<?> option = snippetReflection.asObject(StableOptionValue.class, (JavaConstant) receiver.get().asConstant()); 452 b.addPush(JavaKind.Object, ConstantNode.forConstant(snippetReflection.forObject(option.getValue()), b.getMetaAccess())); 453 return true; 454 } 455 return false; 456 } 457 }); 458 } 459 460 public static final String cbcEncryptName; 461 public static final String cbcDecryptName; 462 public static final String aesEncryptName; 463 public static final String aesDecryptName; 464 465 public static final String reflectionClass; 466 public static final String constantPoolClass; 467 468 static { 469 if (Java8OrEarlier) { 470 cbcEncryptName = "encrypt"; 471 cbcDecryptName = "decrypt"; 472 aesEncryptName = "encryptBlock"; 473 aesDecryptName = "decryptBlock"; 474 reflectionClass = "sun.reflect.Reflection"; 475 constantPoolClass = "sun.reflect.ConstantPool"; 476 } else { 477 cbcEncryptName = "implEncrypt"; 478 cbcDecryptName = "implDecrypt"; 479 aesEncryptName = "implEncryptBlock"; 480 aesDecryptName = "implDecryptBlock"; 481 reflectionClass = "jdk.internal.reflect.Reflection"; 482 constantPoolClass = "jdk.internal.reflect.ConstantPool"; 483 } 484 } 485 486 private static void registerAESPlugins(InvocationPlugins plugins, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 487 if (config.useAESIntrinsics) { 488 assert config.aescryptEncryptBlockStub != 0L; 489 assert config.aescryptDecryptBlockStub != 0L; 490 assert config.cipherBlockChainingEncryptAESCryptStub != 0L; 491 assert config.cipherBlockChainingDecryptAESCryptStub != 0L; 492 String arch = config.osArch; 493 String decryptSuffix = arch.equals("sparc") ? "WithOriginalKey" : ""; 494 Registration r = new Registration(plugins, "com.sun.crypto.provider.CipherBlockChaining", bytecodeProvider); 495 r.registerMethodSubstitution(CipherBlockChainingSubstitutions.class, cbcEncryptName, Receiver.class, byte[].class, int.class, int.class, byte[].class, int.class); 496 r.registerMethodSubstitution(CipherBlockChainingSubstitutions.class, cbcDecryptName, cbcDecryptName + decryptSuffix, Receiver.class, byte[].class, int.class, int.class, byte[].class, 497 int.class); 498 r = new Registration(plugins, "com.sun.crypto.provider.AESCrypt", bytecodeProvider); 499 r.registerMethodSubstitution(AESCryptSubstitutions.class, aesEncryptName, Receiver.class, byte[].class, int.class, byte[].class, int.class); 500 r.registerMethodSubstitution(AESCryptSubstitutions.class, aesDecryptName, aesDecryptName + decryptSuffix, Receiver.class, byte[].class, int.class, byte[].class, int.class); 501 } 502 } 503 504 private static void registerBigIntegerPlugins(InvocationPlugins plugins, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 505 Registration r = new Registration(plugins, BigInteger.class, bytecodeProvider); 506 if (config.useMultiplyToLenIntrinsic()) { 507 assert config.multiplyToLen != 0L; 508 if (Java8OrEarlier) { 509 try { 510 Method m = BigInteger.class.getDeclaredMethod("multiplyToLen", int[].class, int.class, int[].class, int.class, int[].class); 511 if (Modifier.isStatic(m.getModifiers())) { 512 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "multiplyToLen", "multiplyToLenStatic", int[].class, int.class, int[].class, int.class, 513 int[].class); 514 } else { 515 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "multiplyToLen", Receiver.class, int[].class, int.class, int[].class, int.class, 516 int[].class); 517 } 518 } catch (NoSuchMethodException | SecurityException e) { 519 throw new GraalError(e); 520 } 521 } else { 522 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "implMultiplyToLen", "multiplyToLenStatic", int[].class, int.class, int[].class, int.class, 523 int[].class); 524 } 525 } 526 if (config.useMulAddIntrinsic()) { 527 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "implMulAdd", int[].class, int[].class, int.class, int.class, int.class); 528 } 529 if (config.useMontgomeryMultiplyIntrinsic()) { 530 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "implMontgomeryMultiply", int[].class, int[].class, int[].class, int.class, long.class, int[].class); 531 } 532 if (config.useMontgomerySquareIntrinsic()) { 533 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "implMontgomerySquare", int[].class, int[].class, int.class, long.class, int[].class); 534 } 535 if (config.useSquareToLenIntrinsic()) { 536 r.registerMethodSubstitution(BigIntegerSubstitutions.class, "implSquareToLen", int[].class, int.class, int[].class, int.class); 537 } 538 } 539 540 private static void registerSHAPlugins(InvocationPlugins plugins, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 541 if (config.useSHA1Intrinsics()) { 542 assert config.sha1ImplCompress != 0L; 543 Registration r = new Registration(plugins, "sun.security.provider.SHA", bytecodeProvider); 544 r.registerMethodSubstitution(SHASubstitutions.class, SHASubstitutions.implCompressName, "implCompress0", Receiver.class, byte[].class, int.class); 545 } 546 if (config.useSHA256Intrinsics()) { 547 assert config.sha256ImplCompress != 0L; 548 Registration r = new Registration(plugins, "sun.security.provider.SHA2", bytecodeProvider); 549 r.registerMethodSubstitution(SHA2Substitutions.class, SHA2Substitutions.implCompressName, "implCompress0", Receiver.class, byte[].class, int.class); 550 } 551 if (config.useSHA512Intrinsics()) { 552 assert config.sha512ImplCompress != 0L; 553 Registration r = new Registration(plugins, "sun.security.provider.SHA5", bytecodeProvider); 554 r.registerMethodSubstitution(SHA5Substitutions.class, SHA5Substitutions.implCompressName, "implCompress0", Receiver.class, byte[].class, int.class); 555 } 556 } 557 558 private static void registerCRC32Plugins(InvocationPlugins plugins, GraalHotSpotVMConfig config, BytecodeProvider bytecodeProvider) { 559 if (config.useCRC32Intrinsics) { 560 Registration r = new Registration(plugins, CRC32.class, bytecodeProvider); 561 r.registerMethodSubstitution(CRC32Substitutions.class, "update", int.class, int.class); 562 if (Java8OrEarlier) { 563 r.registerMethodSubstitution(CRC32Substitutions.class, "updateBytes", int.class, byte[].class, int.class, int.class); 564 r.registerMethodSubstitution(CRC32Substitutions.class, "updateByteBuffer", int.class, long.class, int.class, int.class); 565 } else { 566 r.registerMethodSubstitution(CRC32Substitutions.class, "updateBytes0", int.class, byte[].class, int.class, int.class); 567 r.registerMethodSubstitution(CRC32Substitutions.class, "updateByteBuffer0", int.class, long.class, int.class, int.class); 568 } 569 } 570 } 571} 572