hotspot Sdiff src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java

src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java

src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java

Print this page

 230 import static org.graalvm.compiler.bytecode.Bytecodes.PUTFIELD;
 231 import static org.graalvm.compiler.bytecode.Bytecodes.PUTSTATIC;
 232 import static org.graalvm.compiler.bytecode.Bytecodes.RET;
 233 import static org.graalvm.compiler.bytecode.Bytecodes.RETURN;
 234 import static org.graalvm.compiler.bytecode.Bytecodes.SALOAD;
 235 import static org.graalvm.compiler.bytecode.Bytecodes.SASTORE;
 236 import static org.graalvm.compiler.bytecode.Bytecodes.SIPUSH;
 237 import static org.graalvm.compiler.bytecode.Bytecodes.SWAP;
 238 import static org.graalvm.compiler.bytecode.Bytecodes.TABLESWITCH;
 239 import static org.graalvm.compiler.bytecode.Bytecodes.nameOf;
 240 import static org.graalvm.compiler.core.common.GraalOptions.DeoptALot;
 241 import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;
 242 import static org.graalvm.compiler.core.common.GraalOptions.HotSpotPrintInlining;
 243 import static org.graalvm.compiler.core.common.GraalOptions.PrintProfilingInformation;
 244 import static org.graalvm.compiler.core.common.GraalOptions.ResolveClassBeforeStaticInvoke;
 245 import static org.graalvm.compiler.core.common.GraalOptions.StressExplicitExceptionCode;
 246 import static org.graalvm.compiler.core.common.GraalOptions.StressInvokeWithExceptionNode;
 247 import static org.graalvm.compiler.core.common.type.StampFactory.objectNonNull;
 248 import static org.graalvm.compiler.debug.GraalError.guarantee;
 249 import static org.graalvm.compiler.debug.GraalError.shouldNotReachHere;
 250 import static org.graalvm.compiler.java.BytecodeParserOptions.DumpWithInfopoints;
 251 import static org.graalvm.compiler.java.BytecodeParserOptions.InlinePartialIntrinsicExitDuringParsing;
 252 import static org.graalvm.compiler.java.BytecodeParserOptions.TraceBytecodeParserLevel;
 253 import static org.graalvm.compiler.java.BytecodeParserOptions.TraceInlineDuringParsing;
 254 import static org.graalvm.compiler.java.BytecodeParserOptions.TraceParserPlugins;
 255 import static org.graalvm.compiler.java.BytecodeParserOptions.UseGuardedIntrinsics;
 256 import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.FAST_PATH_PROBABILITY;
 257 import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.SLOW_PATH_PROBABILITY;
 258 import static org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext.CompilationContext.INLINE_DURING_PARSING;
 259 import static org.graalvm.compiler.nodes.type.StampTool.isPointerNonNull;
 260 
 261 import java.util.ArrayList;
 262 import java.util.Collections;
 263 import java.util.Comparator;
 264 import java.util.Formatter;
 265 import java.util.List;
 266 
 267 import org.graalvm.compiler.api.replacements.Snippet;
 268 import org.graalvm.compiler.bytecode.Bytecode;
 269 import org.graalvm.compiler.bytecode.BytecodeDisassembler;
 270 import org.graalvm.compiler.bytecode.BytecodeLookupSwitch;

2791 
2792             stream.next();
2793             bci = stream.currentBCI();
2794 
2795             assert block == currentBlock;
2796             assert checkLastInstruction();
2797             lastInstr = finishInstruction(lastInstr, frameState);
2798             if (bci < endBCI) {
2799                 if (bci > block.endBci) {
2800                     assert !block.getSuccessor(0).isExceptionEntry;
2801                     assert block.numNormalSuccessors() == 1;
2802                     // we fell through to the next block, add a goto and break
2803                     appendGoto(block.getSuccessor(0));
2804                     break;
2805                 }
2806             }
2807         }
2808     }
2809 
2810     private DebugCloseable openNodeContext() {
2811         if ((graphBuilderConfig.trackNodeSourcePosition() || (Debug.isDumpEnabledForMethod() && DumpWithInfopoints.getValue(options))) && !parsingIntrinsic()) {
2812             return graph.withNodeSourcePosition(createBytecodePosition());
2813         }
2814         return null;
2815     }
2816 
2817     /* Also a hook for subclasses. */
2818     protected boolean forceLoopPhis() {
2819         return graph.isOSR();
2820     }
2821 
2822     /* Hook for subclasses. */
2823     protected boolean stampFromValueForForcedPhis() {
2824         return false;
2825     }
2826 
2827     protected boolean checkLastInstruction() {
2828         if (lastInstr instanceof BeginNode) {
2829             // ignore
2830         } else if (lastInstr instanceof StateSplit) {
2831             StateSplit stateSplit = (StateSplit) lastInstr;

3670             if (plugin.handleNewArray(this, elementType, length)) {
3671                 return;
3672             }
3673         }
3674 
3675         frameState.push(JavaKind.Object, append(createNewArray(elementType, length, true)));
3676     }
3677 
3678     private void genNewObjectArray(int cpi) {
3679         JavaType type = lookupType(cpi, ANEWARRAY);
3680 
3681         if (!(type instanceof ResolvedJavaType)) {
3682             ValueNode length = frameState.pop(JavaKind.Int);
3683             handleUnresolvedNewObjectArray(type, length);
3684             return;
3685         }
3686 
3687         ResolvedJavaType resolvedType = (ResolvedJavaType) type;
3688 
3689         ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin();
3690         if (classInitializationPlugin != null && classInitializationPlugin.shouldApply(this, resolvedType)) {
3691             FrameState stateBefore = frameState.create(bci(), getNonIntrinsicAncestor(), false, null, null);
3692             classInitializationPlugin.apply(this, resolvedType, stateBefore);
3693         }
3694 
3695         ValueNode length = frameState.pop(JavaKind.Int);
3696         for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
3697             if (plugin.handleNewArray(this, resolvedType, length)) {
3698                 return;
3699             }
3700         }
3701 
3702         frameState.push(JavaKind.Object, append(createNewArray(resolvedType, length, true)));
3703     }
3704 
3705     private void genNewMultiArray(int cpi) {
3706         JavaType type = lookupType(cpi, MULTIANEWARRAY);
3707         int rank = getStream().readUByte(bci() + 3);
3708         ValueNode[] dims = new ValueNode[rank];
3709 
3710         if (!(type instanceof ResolvedJavaType)) {
3711             for (int i = rank - 1; i >= 0; i--) {
3712                 dims[i] = frameState.pop(JavaKind.Int);

 230 import static org.graalvm.compiler.bytecode.Bytecodes.PUTFIELD;
 231 import static org.graalvm.compiler.bytecode.Bytecodes.PUTSTATIC;
 232 import static org.graalvm.compiler.bytecode.Bytecodes.RET;
 233 import static org.graalvm.compiler.bytecode.Bytecodes.RETURN;
 234 import static org.graalvm.compiler.bytecode.Bytecodes.SALOAD;
 235 import static org.graalvm.compiler.bytecode.Bytecodes.SASTORE;
 236 import static org.graalvm.compiler.bytecode.Bytecodes.SIPUSH;
 237 import static org.graalvm.compiler.bytecode.Bytecodes.SWAP;
 238 import static org.graalvm.compiler.bytecode.Bytecodes.TABLESWITCH;
 239 import static org.graalvm.compiler.bytecode.Bytecodes.nameOf;
 240 import static org.graalvm.compiler.core.common.GraalOptions.DeoptALot;
 241 import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;
 242 import static org.graalvm.compiler.core.common.GraalOptions.HotSpotPrintInlining;
 243 import static org.graalvm.compiler.core.common.GraalOptions.PrintProfilingInformation;
 244 import static org.graalvm.compiler.core.common.GraalOptions.ResolveClassBeforeStaticInvoke;
 245 import static org.graalvm.compiler.core.common.GraalOptions.StressExplicitExceptionCode;
 246 import static org.graalvm.compiler.core.common.GraalOptions.StressInvokeWithExceptionNode;
 247 import static org.graalvm.compiler.core.common.type.StampFactory.objectNonNull;
 248 import static org.graalvm.compiler.debug.GraalError.guarantee;
 249 import static org.graalvm.compiler.debug.GraalError.shouldNotReachHere;

 250 import static org.graalvm.compiler.java.BytecodeParserOptions.InlinePartialIntrinsicExitDuringParsing;
 251 import static org.graalvm.compiler.java.BytecodeParserOptions.TraceBytecodeParserLevel;
 252 import static org.graalvm.compiler.java.BytecodeParserOptions.TraceInlineDuringParsing;
 253 import static org.graalvm.compiler.java.BytecodeParserOptions.TraceParserPlugins;
 254 import static org.graalvm.compiler.java.BytecodeParserOptions.UseGuardedIntrinsics;
 255 import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.FAST_PATH_PROBABILITY;
 256 import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.SLOW_PATH_PROBABILITY;
 257 import static org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext.CompilationContext.INLINE_DURING_PARSING;
 258 import static org.graalvm.compiler.nodes.type.StampTool.isPointerNonNull;
 259 
 260 import java.util.ArrayList;
 261 import java.util.Collections;
 262 import java.util.Comparator;
 263 import java.util.Formatter;
 264 import java.util.List;
 265 
 266 import org.graalvm.compiler.api.replacements.Snippet;
 267 import org.graalvm.compiler.bytecode.Bytecode;
 268 import org.graalvm.compiler.bytecode.BytecodeDisassembler;
 269 import org.graalvm.compiler.bytecode.BytecodeLookupSwitch;

2790 
2791             stream.next();
2792             bci = stream.currentBCI();
2793 
2794             assert block == currentBlock;
2795             assert checkLastInstruction();
2796             lastInstr = finishInstruction(lastInstr, frameState);
2797             if (bci < endBCI) {
2798                 if (bci > block.endBci) {
2799                     assert !block.getSuccessor(0).isExceptionEntry;
2800                     assert block.numNormalSuccessors() == 1;
2801                     // we fell through to the next block, add a goto and break
2802                     appendGoto(block.getSuccessor(0));
2803                     break;
2804                 }
2805             }
2806         }
2807     }
2808 
2809     private DebugCloseable openNodeContext() {
2810         if ((graphBuilderConfig.trackNodeSourcePosition() || Debug.isDumpEnabledForMethod()) && !parsingIntrinsic()) {
2811             return graph.withNodeSourcePosition(createBytecodePosition());
2812         }
2813         return null;
2814     }
2815 
2816     /* Also a hook for subclasses. */
2817     protected boolean forceLoopPhis() {
2818         return graph.isOSR();
2819     }
2820 
2821     /* Hook for subclasses. */
2822     protected boolean stampFromValueForForcedPhis() {
2823         return false;
2824     }
2825 
2826     protected boolean checkLastInstruction() {
2827         if (lastInstr instanceof BeginNode) {
2828             // ignore
2829         } else if (lastInstr instanceof StateSplit) {
2830             StateSplit stateSplit = (StateSplit) lastInstr;

3669             if (plugin.handleNewArray(this, elementType, length)) {
3670                 return;
3671             }
3672         }
3673 
3674         frameState.push(JavaKind.Object, append(createNewArray(elementType, length, true)));
3675     }
3676 
3677     private void genNewObjectArray(int cpi) {
3678         JavaType type = lookupType(cpi, ANEWARRAY);
3679 
3680         if (!(type instanceof ResolvedJavaType)) {
3681             ValueNode length = frameState.pop(JavaKind.Int);
3682             handleUnresolvedNewObjectArray(type, length);
3683             return;
3684         }
3685 
3686         ResolvedJavaType resolvedType = (ResolvedJavaType) type;
3687 
3688         ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin();
3689         if (classInitializationPlugin != null && classInitializationPlugin.shouldApply(this, resolvedType.getArrayClass())) {
3690             FrameState stateBefore = frameState.create(bci(), getNonIntrinsicAncestor(), false, null, null);
3691             classInitializationPlugin.apply(this, resolvedType.getArrayClass(), stateBefore);
3692         }
3693 
3694         ValueNode length = frameState.pop(JavaKind.Int);
3695         for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
3696             if (plugin.handleNewArray(this, resolvedType, length)) {
3697                 return;
3698             }
3699         }
3700 
3701         frameState.push(JavaKind.Object, append(createNewArray(resolvedType, length, true)));
3702     }
3703 
3704     private void genNewMultiArray(int cpi) {
3705         JavaType type = lookupType(cpi, MULTIANEWARRAY);
3706         int rank = getStream().readUByte(bci() + 3);
3707         ValueNode[] dims = new ValueNode[rank];
3708 
3709         if (!(type instanceof ResolvedJavaType)) {
3710             for (int i = rank - 1; i >= 0; i--) {
3711                 dims[i] = frameState.pop(JavaKind.Int);