truffle: graal/com.oracle.graal.java/src/com/oracle/graal/java/BytecodeParser.java annotate

annotate graal/com.oracle.graal.java/src/com/oracle/graal/java/BytecodeParser.java @ 21609:2221d959de64

Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Fri, 29 May 2015 19:11:39 -0700
parents
children	d246f7b59166

rev	line source
21609 2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2 * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	4 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	7 * published by the Free Software Foundation.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	8 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	13 * accompanied this code).
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	14 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	18 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	20 * or visit www.oracle.com if you need additional information or have any
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	21 * questions.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	22 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	23 package com.oracle.graal.java;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	24
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	25 import static com.oracle.graal.bytecode.Bytecodes.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	26 import static com.oracle.graal.compiler.common.GraalOptions.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	27 import static com.oracle.graal.compiler.common.type.StampFactory.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	28 import static com.oracle.graal.graphbuilderconf.IntrinsicContext.CompilationContext.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	29 import static com.oracle.graal.java.BytecodeParser.Options.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	30 import static com.oracle.graal.nodes.StructuredGraph.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	31 import static com.oracle.graal.nodes.type.StampTool.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	32 import static com.oracle.jvmci.code.TypeCheckHints.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	33 import static com.oracle.jvmci.common.JVMCIError.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	34 import static com.oracle.jvmci.meta.DeoptimizationAction.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	35 import static com.oracle.jvmci.meta.DeoptimizationReason.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	36 import static java.lang.String.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	37
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	38 import java.util.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	39
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	40 import com.oracle.graal.bytecode.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	41 import com.oracle.graal.compiler.common.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	42 import com.oracle.graal.compiler.common.calc.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	43 import com.oracle.graal.compiler.common.type.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	44 import com.oracle.graal.graph.Graph.Mark;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	45 import com.oracle.graal.graph.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	46 import com.oracle.graal.graph.Node.ValueNumberable;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	47 import com.oracle.graal.graph.iterators.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	48 import com.oracle.graal.graphbuilderconf.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	49 import com.oracle.graal.graphbuilderconf.InlineInvokePlugin.InlineInfo;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	50 import com.oracle.graal.graphbuilderconf.InvocationPlugins.InvocationPluginReceiver;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	51 import com.oracle.graal.java.BciBlockMapping.BciBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	52 import com.oracle.graal.java.BciBlockMapping.ExceptionDispatchBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	53 import com.oracle.graal.nodeinfo.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	54 import com.oracle.graal.nodes.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	55 import com.oracle.graal.nodes.CallTargetNode.InvokeKind;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	56 import com.oracle.graal.nodes.calc.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	57 import com.oracle.graal.nodes.extended.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	58 import com.oracle.graal.nodes.java.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	59 import com.oracle.graal.nodes.spi.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	60 import com.oracle.graal.nodes.type.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	61 import com.oracle.graal.nodes.util.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	62 import com.oracle.graal.phases.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	63 import com.oracle.jvmci.code.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	64 import com.oracle.jvmci.common.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	65 import com.oracle.jvmci.debug.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	66 import com.oracle.jvmci.debug.Debug.Scope;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	67 import com.oracle.jvmci.meta.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	68 import com.oracle.jvmci.options.*;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	69
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	70 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	71 * The {@code GraphBuilder} class parses the bytecode of a method and builds the IR graph.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	72 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	73 public class BytecodeParser implements GraphBuilderContext {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	74
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	75 public static class Options {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	76 @Option(help = "The trace level for the bytecode parser used when building a graph from bytecode", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	77 public static final OptionValue<Integer> TraceBytecodeParserLevel = new OptionValue<>(0);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	78
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	79 @Option(help = "Inlines trivial methods during bytecode parsing.", type = OptionType.Expert)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	80 public static final StableOptionValue<Boolean> InlineDuringParsing = new StableOptionValue<>(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	81
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	82 @Option(help = "Inlines intrinsic methods during bytecode parsing.", type = OptionType.Expert)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	83 public static final StableOptionValue<Boolean> InlineIntrinsicsDuringParsing = new StableOptionValue<>(true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	84
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	85 @Option(help = "Traces inlining performed during bytecode parsing.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	86 public static final StableOptionValue<Boolean> TraceInlineDuringParsing = new StableOptionValue<>(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	87
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	88 @Option(help = "Traces use of plugins during bytecode parsing.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	89 public static final StableOptionValue<Boolean> TraceParserPlugins = new StableOptionValue<>(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	90
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	91 @Option(help = "Maximum depth when inlining during bytecode parsing.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	92 public static final StableOptionValue<Integer> InlineDuringParsingMaxDepth = new StableOptionValue<>(10);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	93
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	94 @Option(help = "Dump graphs after non-trivial changes during bytecode parsing.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	95 public static final StableOptionValue<Boolean> DumpDuringGraphBuilding = new StableOptionValue<>(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	96
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	97 @Option(help = "Max number of loop explosions per method.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	98 public static final OptionValue<Integer> MaximumLoopExplosionCount = new OptionValue<>(10000);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	99
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	100 @Option(help = "Do not bail out but throw an exception on failed loop explosion.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	101 public static final OptionValue<Boolean> FailedLoopExplosionIsFatal = new OptionValue<>(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	102
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	103 @Option(help = "When creating info points hide the methods of the substitutions.", type = OptionType.Debug)//
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	104 public static final OptionValue<Boolean> HideSubstitutionStates = new OptionValue<>(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	105 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	106
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	107 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	108 * The minimum value to which {@link Options#TraceBytecodeParserLevel} must be set to trace the
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	109 * bytecode instructions as they are parsed.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	110 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	111 public static final int TRACELEVEL_INSTRUCTIONS = 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	112
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	113 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	114 * The minimum value to which {@link Options#TraceBytecodeParserLevel} must be set to trace the
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	115 * frame state before each bytecode instruction as it is parsed.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	116 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	117 public static final int TRACELEVEL_STATE = 2;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	118
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	119 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	120 * Meters the number of actual bytecodes parsed.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	121 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	122 public static final DebugMetric BytecodesParsed = Debug.metric("BytecodesParsed");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	123
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	124 protected static final DebugMetric EXPLICIT_EXCEPTIONS = Debug.metric("ExplicitExceptions");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	125
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	126 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	127 * A scoped object for tasks to be performed after parsing an intrinsic such as processing
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	128 * {@linkplain BytecodeFrame#isPlaceholderBci(int) placeholder} frames states.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	129 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	130 static class IntrinsicScope implements AutoCloseable {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	131 FrameState stateBefore;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	132 final Mark mark;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	133 final BytecodeParser parser;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	134
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	135 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	136 * Creates a scope for root parsing an intrinsic.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	137 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	138 * @param parser the parsing context of the intrinsic
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	139 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	140 public IntrinsicScope(BytecodeParser parser) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	141 this.parser = parser;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	142 assert parser.parent == null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	143 assert parser.bci() == 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	144 mark = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	145 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	146
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	147 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	148 * Creates a scope for parsing an intrinsic during graph builder inlining.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	149 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	150 * @param parser the parsing context of the (non-intrinsic) method calling the intrinsic
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	151 * @param args the arguments to the call
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	152 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	153 public IntrinsicScope(BytecodeParser parser, Kind[] argSlotKinds, ValueNode[] args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	154 assert !parser.parsingIntrinsic();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	155 this.parser = parser;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	156 mark = parser.getGraph().getMark();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	157 stateBefore = parser.frameState.create(parser.bci(), parser.getNonIntrinsicAncestor(), false, argSlotKinds, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	158 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	159
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	160 public void close() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	161 IntrinsicContext intrinsic = parser.intrinsicContext;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	162 if (intrinsic != null && intrinsic.isPostParseInlined()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	163 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	164 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	165
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	166 processPlaceholderFrameStates(intrinsic);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	167 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	168
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	169 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	170 * Fixes up the {@linkplain BytecodeFrame#isPlaceholderBci(int) placeholder} frame states
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	171 * added to the graph while parsing/inlining the intrinsic for which this object exists.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	172 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	173 private void processPlaceholderFrameStates(IntrinsicContext intrinsic) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	174 FrameState stateAfterReturn = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	175 StructuredGraph graph = parser.getGraph();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	176 for (Node node : graph.getNewNodes(mark)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	177 if (node instanceof FrameState) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	178 FrameState frameState = (FrameState) node;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	179 if (BytecodeFrame.isPlaceholderBci(frameState.bci)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	180 if (frameState.bci == BytecodeFrame.AFTER_BCI) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	181 FrameStateBuilder frameStateBuilder = parser.frameState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	182 if (frameState.stackSize() != 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	183 assert frameState.usages().count() == 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	184 ValueNode returnVal = frameState.stackAt(0);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	185 assert returnVal == frameState.usages().first();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	186
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	187 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	188 * Swap the top-of-stack value with the side-effect return value
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	189 * using the frame state.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	190 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	191 Kind returnKind = parser.currentInvokeReturnType.getKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	192 ValueNode tos = frameStateBuilder.pop(returnKind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	193 assert tos.getKind() == returnVal.getKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	194 FrameState newFrameState = frameStateBuilder.create(parser.stream.nextBCI(), parser.getNonIntrinsicAncestor(), false, new Kind[]{returnKind},
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	195 new ValueNode[]{returnVal});
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	196 frameState.replaceAndDelete(newFrameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	197 frameStateBuilder.push(returnKind, tos);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	198 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	199 if (stateAfterReturn == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	200 if (intrinsic != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	201 assert intrinsic.isCompilationRoot();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	202 stateAfterReturn = graph.add(new FrameState(BytecodeFrame.INVALID_FRAMESTATE_BCI));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	203 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	204 stateAfterReturn = frameStateBuilder.create(parser.stream.nextBCI(), null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	205 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	206 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	207 frameState.replaceAndDelete(stateAfterReturn);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	208 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	209 } else if (frameState.bci == BytecodeFrame.BEFORE_BCI) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	210 if (stateBefore == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	211 stateBefore = graph.start().stateAfter();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	212 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	213 if (stateBefore != frameState) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	214 frameState.replaceAndDelete(stateBefore);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	215 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	216 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	217 assert frameState.bci == BytecodeFrame.INVALID_FRAMESTATE_BCI;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	218 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	219 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	220 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	221 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	222 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	223 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	224
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	225 private static class Target {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	226 FixedNode fixed;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	227 FrameStateBuilder state;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	228
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	229 public Target(FixedNode fixed, FrameStateBuilder state) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	230 this.fixed = fixed;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	231 this.state = state;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	232 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	233 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	234
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	235 private static class ExplodedLoopContext {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	236 private BciBlock header;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	237 private int[] targetPeelIteration;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	238 private int peelIteration;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	239 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	240
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	241 @SuppressWarnings("serial")
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	242 public static class BytecodeParserError extends JVMCIError {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	243
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	244 public BytecodeParserError(Throwable cause) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	245 super(cause);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	246 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	247
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	248 public BytecodeParserError(String msg, Object... args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	249 super(msg, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	250 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	251 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	252
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	253 private final GraphBuilderPhase.Instance graphBuilderInstance;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	254 protected final StructuredGraph graph;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	255
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	256 private BciBlockMapping blockMap;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	257 private LocalLiveness liveness;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	258 protected final int entryBCI;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	259 private final BytecodeParser parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	260
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	261 private LineNumberTable lnt;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	262 private int previousLineNumber;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	263 private int currentLineNumber;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	264
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	265 private ValueNode methodSynchronizedObject;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	266
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	267 private ValueNode returnValue;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	268 private FixedWithNextNode beforeReturnNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	269 private ValueNode unwindValue;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	270 private FixedWithNextNode beforeUnwindNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	271
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	272 private FixedWithNextNode lastInstr; // the last instruction added
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	273 private final boolean explodeLoops;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	274 private final boolean mergeExplosions;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	275 private final Map<FrameStateBuilder, Integer> mergeExplosionsMap;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	276 private Deque<ExplodedLoopContext> explodeLoopsContext;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	277 private int nextPeelIteration = 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	278 private boolean controlFlowSplit;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	279 private final InvocationPluginReceiver invocationPluginReceiver = new InvocationPluginReceiver(this);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	280
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	281 private FixedWithNextNode[] firstInstructionArray;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	282 private FrameStateBuilder[] entryStateArray;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	283 private FixedWithNextNode[][] firstInstructionMatrix;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	284 private FrameStateBuilder[][] entryStateMatrix;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	285
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	286 protected BytecodeParser(GraphBuilderPhase.Instance graphBuilderInstance, StructuredGraph graph, BytecodeParser parent, ResolvedJavaMethod method, int entryBCI, IntrinsicContext intrinsicContext) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	287 this.graphBuilderInstance = graphBuilderInstance;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	288 this.graph = graph;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	289 this.graphBuilderConfig = graphBuilderInstance.graphBuilderConfig;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	290 this.optimisticOpts = graphBuilderInstance.optimisticOpts;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	291 this.metaAccess = graphBuilderInstance.metaAccess;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	292 this.stampProvider = graphBuilderInstance.stampProvider;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	293 this.constantReflection = graphBuilderInstance.constantReflection;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	294 this.stream = new BytecodeStream(method.getCode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	295 this.profilingInfo = (graphBuilderConfig.getUseProfiling() ? method.getProfilingInfo() : null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	296 this.constantPool = method.getConstantPool();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	297 this.method = method;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	298 this.intrinsicContext = intrinsicContext;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	299 this.entryBCI = entryBCI;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	300 this.parent = parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	301
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	302 assert method.getCode() != null : "method must contain bytecodes: " + method;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	303
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	304 if (graphBuilderConfig.insertNonSafepointDebugInfo() && !parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	305 lnt = method.getLineNumberTable();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	306 previousLineNumber = -1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	307 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	308
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	309 LoopExplosionPlugin loopExplosionPlugin = graphBuilderConfig.getPlugins().getLoopExplosionPlugin();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	310 if (loopExplosionPlugin != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	311 explodeLoops = loopExplosionPlugin.shouldExplodeLoops(method);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	312 if (explodeLoops) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	313 mergeExplosions = loopExplosionPlugin.shouldMergeExplosions(method);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	314 mergeExplosionsMap = new HashMap<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	315 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	316 mergeExplosions = false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	317 mergeExplosionsMap = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	318 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	319 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	320 explodeLoops = false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	321 mergeExplosions = false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	322 mergeExplosionsMap = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	323 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	324 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	325
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	326 public ValueNode getReturnValue() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	327 return returnValue;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	328 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	329
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	330 public FixedWithNextNode getBeforeReturnNode() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	331 return this.beforeReturnNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	332 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	333
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	334 public ValueNode getUnwindValue() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	335 return unwindValue;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	336 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	337
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	338 public FixedWithNextNode getBeforeUnwindNode() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	339 return this.beforeUnwindNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	340 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	341
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	342 protected void buildRootMethod() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	343 FrameStateBuilder startFrameState = new FrameStateBuilder(this, method, graph);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	344 startFrameState.initializeForMethodStart(graphBuilderConfig.eagerResolving() \|\| intrinsicContext != null, graphBuilderConfig.getPlugins().getParameterPlugins());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	345
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	346 try (IntrinsicScope s = intrinsicContext != null ? new IntrinsicScope(this) : null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	347 build(graph.start(), startFrameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	348 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	349
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	350 cleanupFinalGraph();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	351 ComputeLoopFrequenciesClosure.compute(graph);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	352 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	353
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	354 protected void build(FixedWithNextNode startInstruction, FrameStateBuilder startFrameState) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	355 if (PrintProfilingInformation.getValue() && profilingInfo != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	356 TTY.println("Profiling info for " + method.format("%H.%n(%p)"));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	357 TTY.println(MetaUtil.indent(profilingInfo.toString(method, CodeUtil.NEW_LINE), " "));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	358 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	359
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	360 try (Indent indent = Debug.logAndIndent("build graph for %s", method)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	361
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	362 // compute the block map, setup exception handlers and get the entrypoint(s)
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	363 BciBlockMapping newMapping = BciBlockMapping.create(stream, method);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	364 this.blockMap = newMapping;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	365 this.firstInstructionArray = new FixedWithNextNode[blockMap.getBlockCount()];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	366 this.entryStateArray = new FrameStateBuilder[blockMap.getBlockCount()];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	367
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	368 try (Scope s = Debug.scope("LivenessAnalysis")) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	369 int maxLocals = method.getMaxLocals();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	370 liveness = LocalLiveness.compute(stream, blockMap.getBlocks(), maxLocals, blockMap.getLoopCount());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	371 } catch (Throwable e) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	372 throw Debug.handle(e);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	373 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	374
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	375 lastInstr = startInstruction;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	376 this.setCurrentFrameState(startFrameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	377 stream.setBCI(0);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	378
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	379 BciBlock startBlock = blockMap.getStartBlock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	380 if (startInstruction == graph.start()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	381 StartNode startNode = graph.start();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	382 if (method.isSynchronized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	383 assert !parsingIntrinsic();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	384 startNode.setStateAfter(createFrameState(BytecodeFrame.BEFORE_BCI, startNode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	385 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	386 if (!parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	387 if (graph.method() != null && graph.method().isJavaLangObjectInit()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	388 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	389 * Don't clear the receiver when Object.<init> is the compilation root.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	390 * The receiver is needed as input to RegisterFinalizerNode.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	391 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	392 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	393 frameState.clearNonLiveLocals(startBlock, liveness, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	394 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	395 assert bci() == 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	396 startNode.setStateAfter(createFrameState(bci(), startNode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	397 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	398 if (startNode.stateAfter() == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	399 FrameState stateAfterStart = createStateAfterStartOfReplacementGraph();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	400 startNode.setStateAfter(stateAfterStart);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	401 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	402 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	403 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	404 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	405
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	406 if (method.isSynchronized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	407 // add a monitor enter to the start block
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	408 methodSynchronizedObject = synchronizedObject(frameState, method);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	409 frameState.clearNonLiveLocals(startBlock, liveness, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	410 assert bci() == 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	411 genMonitorEnter(methodSynchronizedObject, bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	412 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	413
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	414 if (graphBuilderConfig.insertNonSafepointDebugInfo() && !parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	415 append(createInfoPointNode(InfopointReason.METHOD_START));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	416 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	417
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	418 currentBlock = blockMap.getStartBlock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	419 setEntryState(startBlock, 0, frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	420 if (startBlock.isLoopHeader && !explodeLoops) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	421 appendGoto(startBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	422 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	423 setFirstInstruction(startBlock, 0, lastInstr);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	424 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	425
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	426 int index = 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	427 BciBlock[] blocks = blockMap.getBlocks();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	428 while (index < blocks.length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	429 BciBlock block = blocks[index];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	430 index = iterateBlock(blocks, block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	431 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	432
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	433 if (this.mergeExplosions) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	434 Debug.dump(graph, "Before loop detection");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	435 detectLoops(startInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	436 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	437
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	438 if (Debug.isDumpEnabled() && DumpDuringGraphBuilding.getValue() && this.beforeReturnNode != startInstruction) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	439 Debug.dump(graph, "Bytecodes parsed: " + method.getDeclaringClass().getUnqualifiedName() + "." + method.getName());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	440 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	441 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	442 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	443
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	444 protected void cleanupFinalGraph() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	445 GraphUtil.normalizeLoops(graph);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	446
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	447 // Remove dead parameters.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	448 for (ParameterNode param : graph.getNodes(ParameterNode.TYPE)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	449 if (param.hasNoUsages()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	450 assert param.inputs().isEmpty();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	451 param.safeDelete();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	452 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	453 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	454
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	455 // Remove redundant begin nodes.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	456 Debug.dump(graph, "Before removing redundant begins");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	457 for (BeginNode beginNode : graph.getNodes(BeginNode.TYPE)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	458 Node predecessor = beginNode.predecessor();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	459 if (predecessor instanceof ControlSplitNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	460 // The begin node is necessary.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	461 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	462 if (beginNode.hasUsages()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	463 reanchorGuardedNodes(beginNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	464 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	465 GraphUtil.unlinkFixedNode(beginNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	466 beginNode.safeDelete();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	467 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	468 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	469 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	470
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	471 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	472 * Removes {@link GuardedNode}s from {@code beginNode}'s usages and re-attaches them to an
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	473 * appropriate preceeding {@link GuardingNode}.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	474 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	475 protected void reanchorGuardedNodes(BeginNode beginNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	476 // Find the new guarding node
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	477 GuardingNode guarding = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	478 Node pred = beginNode.predecessor();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	479 while (pred != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	480 if (pred instanceof BeginNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	481 if (pred.predecessor() instanceof ControlSplitNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	482 guarding = (GuardingNode) pred;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	483 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	484 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	485 } else if (pred.getNodeClass().getAllowedUsageTypes().contains(InputType.Guard)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	486 guarding = (GuardingNode) pred;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	487 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	488 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	489 pred = pred.predecessor();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	490 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	491
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	492 // Reset the guard for all of beginNode's usages
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	493 for (Node usage : beginNode.usages().snapshot()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	494 GuardedNode guarded = (GuardedNode) usage;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	495 assert guarded.getGuard() == beginNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	496 guarded.setGuard(guarding);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	497 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	498 assert beginNode.hasNoUsages() : beginNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	499 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	500
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	501 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	502 * Creates the frame state after the start node of a graph for an {@link IntrinsicContext
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	503 * intrinsic} that is the parse root (either for root compiling or for post-parse inlining).
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	504 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	505 private FrameState createStateAfterStartOfReplacementGraph() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	506 assert parent == null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	507 assert frameState.getMethod().equals(intrinsicContext.getIntrinsicMethod());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	508 assert bci() == 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	509 assert frameState.stackSize() == 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	510 FrameState stateAfterStart;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	511 if (intrinsicContext.isPostParseInlined()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	512 stateAfterStart = graph.add(new FrameState(BytecodeFrame.BEFORE_BCI));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	513 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	514 ResolvedJavaMethod original = intrinsicContext.getOriginalMethod();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	515 ValueNode[] locals;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	516 if (original.getMaxLocals() == frameState.localsSize() \|\| original.isNative()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	517 locals = frameState.locals;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	518 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	519 locals = new ValueNode[original.getMaxLocals()];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	520 int parameterCount = original.getSignature().getParameterCount(!original.isStatic());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	521 for (int i = 0; i < parameterCount; i++) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	522 ValueNode param = frameState.locals[i];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	523 locals[i] = param;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	524 assert param == null \|\| param instanceof ParameterNode \|\| param.isConstant();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	525 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	526 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	527 ValueNode[] stack = {};
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	528 int stackSize = 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	529 ValueNode[] locks = {};
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	530 List<MonitorIdNode> monitorIds = Collections.emptyList();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	531 stateAfterStart = graph.add(new FrameState(null, original, 0, locals, stack, stackSize, locks, monitorIds, false, false));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	532 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	533 return stateAfterStart;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	534 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	535
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	536 private void detectLoops(FixedNode startInstruction) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	537 NodeBitMap visited = graph.createNodeBitMap();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	538 NodeBitMap active = graph.createNodeBitMap();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	539 Deque<Node> stack = new ArrayDeque<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	540 stack.add(startInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	541 visited.mark(startInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	542 while (!stack.isEmpty()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	543 Node next = stack.peek();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	544 assert next.isDeleted() \|\| visited.isMarked(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	545 if (next.isDeleted() \|\| active.isMarked(next)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	546 stack.pop();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	547 if (!next.isDeleted()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	548 active.clear(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	549 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	550 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	551 active.mark(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	552 for (Node n : next.cfgSuccessors()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	553 if (active.contains(n)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	554 // Detected cycle.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	555 assert n instanceof MergeNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	556 assert next instanceof EndNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	557 MergeNode merge = (MergeNode) n;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	558 EndNode endNode = (EndNode) next;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	559 merge.removeEnd(endNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	560 FixedNode afterMerge = merge.next();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	561 if (!(afterMerge instanceof EndNode) \|\| !(((EndNode) afterMerge).merge() instanceof LoopBeginNode)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	562 merge.setNext(null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	563 LoopBeginNode newLoopBegin = this.appendLoopBegin(merge);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	564 newLoopBegin.setNext(afterMerge);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	565 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	566 LoopBeginNode loopBegin = (LoopBeginNode) ((EndNode) merge.next()).merge();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	567 LoopEndNode loopEnd = graph.add(new LoopEndNode(loopBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	568 if (parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	569 loopEnd.disableSafepoint();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	570 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	571 endNode.replaceAndDelete(loopEnd);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	572 } else if (visited.contains(n)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	573 // Normal merge into a branch we are already exploring.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	574 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	575 visited.mark(n);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	576 stack.push(n);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	577 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	578 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	579 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	580 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	581
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	582 Debug.dump(graph, "After loops detected");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	583 insertLoopEnds(startInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	584 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	585
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	586 private void insertLoopEnds(FixedNode startInstruction) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	587 NodeBitMap visited = graph.createNodeBitMap();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	588 Deque<Node> stack = new ArrayDeque<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	589 stack.add(startInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	590 visited.mark(startInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	591 List<LoopBeginNode> loopBegins = new ArrayList<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	592 while (!stack.isEmpty()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	593 Node next = stack.pop();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	594 assert visited.isMarked(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	595 if (next instanceof LoopBeginNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	596 loopBegins.add((LoopBeginNode) next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	597 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	598 for (Node n : next.cfgSuccessors()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	599 if (visited.contains(n)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	600 // Nothing to do.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	601 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	602 visited.mark(n);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	603 stack.push(n);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	604 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	605 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	606 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	607
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	608 IdentityHashMap<LoopBeginNode, List<LoopBeginNode>> innerLoopsMap = new IdentityHashMap<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	609 for (int i = loopBegins.size() - 1; i >= 0; --i) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	610 LoopBeginNode loopBegin = loopBegins.get(i);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	611 insertLoopExits(loopBegin, innerLoopsMap);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	612 if (DumpDuringGraphBuilding.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	613 Debug.dump(graph, "After building loop exits for %s.", loopBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	614 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	615 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	616
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	617 // Remove degenerated merges with only one predecessor.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	618 for (LoopBeginNode loopBegin : loopBegins) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	619 Node pred = loopBegin.forwardEnd().predecessor();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	620 if (pred instanceof MergeNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	621 MergeNode.removeMergeIfDegenerated((MergeNode) pred);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	622 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	623 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	624 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	625
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	626 private void insertLoopExits(LoopBeginNode loopBegin, IdentityHashMap<LoopBeginNode, List<LoopBeginNode>> innerLoopsMap) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	627 NodeBitMap visited = graph.createNodeBitMap();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	628 Deque<Node> stack = new ArrayDeque<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	629 for (LoopEndNode loopEnd : loopBegin.loopEnds()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	630 stack.push(loopEnd);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	631 visited.mark(loopEnd);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	632 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	633
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	634 List<ControlSplitNode> controlSplits = new ArrayList<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	635 List<LoopBeginNode> innerLoopBegins = new ArrayList<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	636
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	637 while (!stack.isEmpty()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	638 Node current = stack.pop();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	639 if (current == loopBegin) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	640 continue;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	641 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	642 for (Node pred : current.cfgPredecessors()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	643 if (!visited.isMarked(pred)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	644 visited.mark(pred);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	645 if (pred instanceof LoopExitNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	646 // Inner loop
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	647 LoopExitNode loopExitNode = (LoopExitNode) pred;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	648 LoopBeginNode innerLoopBegin = loopExitNode.loopBegin();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	649 if (!visited.isMarked(innerLoopBegin)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	650 stack.push(innerLoopBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	651 visited.mark(innerLoopBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	652 innerLoopBegins.add(innerLoopBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	653 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	654 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	655 if (pred instanceof ControlSplitNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	656 ControlSplitNode controlSplitNode = (ControlSplitNode) pred;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	657 controlSplits.add(controlSplitNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	658 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	659 stack.push(pred);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	660 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	661 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	662 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	663 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	664
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	665 for (ControlSplitNode controlSplit : controlSplits) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	666 for (Node succ : controlSplit.cfgSuccessors()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	667 if (!visited.isMarked(succ)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	668 LoopExitNode loopExit = graph.add(new LoopExitNode(loopBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	669 FixedNode next = ((FixedWithNextNode) succ).next();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	670 next.replaceAtPredecessor(loopExit);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	671 loopExit.setNext(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	672 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	673 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	674 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	675
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	676 for (LoopBeginNode inner : innerLoopBegins) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	677 addLoopExits(loopBegin, inner, innerLoopsMap, visited);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	678 if (DumpDuringGraphBuilding.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	679 Debug.dump(graph, "After adding loop exits for %s.", inner);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	680 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	681 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	682
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	683 innerLoopsMap.put(loopBegin, innerLoopBegins);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	684 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	685
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	686 private void addLoopExits(LoopBeginNode loopBegin, LoopBeginNode inner, IdentityHashMap<LoopBeginNode, List<LoopBeginNode>> innerLoopsMap, NodeBitMap visited) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	687 for (LoopExitNode exit : inner.loopExits()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	688 if (!visited.isMarked(exit)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	689 LoopExitNode newLoopExit = graph.add(new LoopExitNode(loopBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	690 FixedNode next = exit.next();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	691 next.replaceAtPredecessor(newLoopExit);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	692 newLoopExit.setNext(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	693 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	694 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	695
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	696 for (LoopBeginNode innerInner : innerLoopsMap.get(inner)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	697 addLoopExits(loopBegin, innerInner, innerLoopsMap, visited);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	698 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	699 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	700
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	701 private int iterateBlock(BciBlock[] blocks, BciBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	702 if (block.isLoopHeader && this.explodeLoops) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	703 return iterateExplodedLoopHeader(blocks, block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	704 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	705 processBlock(this, block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	706 return block.getId() + 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	707 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	708 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	709
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	710 private int iterateExplodedLoopHeader(BciBlock[] blocks, BciBlock header) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	711 if (explodeLoopsContext == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	712 explodeLoopsContext = new ArrayDeque<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	713 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	714
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	715 ExplodedLoopContext context = new ExplodedLoopContext();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	716 context.header = header;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	717 context.peelIteration = this.getCurrentDimension();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	718 if (this.mergeExplosions) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	719 this.addToMergeCache(getEntryState(context.header, context.peelIteration), context.peelIteration);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	720 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	721 explodeLoopsContext.push(context);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	722 if (Debug.isDumpEnabled() && DumpDuringGraphBuilding.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	723 Debug.dump(graph, "before loop explosion dimension " + context.peelIteration);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	724 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	725 peelIteration(blocks, header, context);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	726 explodeLoopsContext.pop();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	727 return header.loopEnd + 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	728 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	729
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	730 private void addToMergeCache(FrameStateBuilder key, int dimension) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	731 mergeExplosionsMap.put(key, dimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	732 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	733
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	734 private void peelIteration(BciBlock[] blocks, BciBlock header, ExplodedLoopContext context) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	735 while (true) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	736 if (TraceParserPlugins.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	737 traceWithContext("exploding loop, iteration %d", context.peelIteration);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	738 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	739 processBlock(this, header);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	740 int j = header.getId() + 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	741 while (j <= header.loopEnd) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	742 BciBlock block = blocks[j];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	743 j = iterateBlock(blocks, block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	744 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	745
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	746 int[] targets = context.targetPeelIteration;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	747 if (targets != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	748 // We were reaching the backedge during explosion. Explode further.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	749 for (int i = 0; i < targets.length; ++i) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	750 context.peelIteration = targets[i];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	751 context.targetPeelIteration = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	752 if (Debug.isDumpEnabled() && DumpDuringGraphBuilding.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	753 Debug.dump(graph, "next loop explosion iteration " + context.peelIteration);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	754 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	755 if (i < targets.length - 1) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	756 peelIteration(blocks, header, context);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	757 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	758 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	759 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	760 // We did not reach the backedge. Exit.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	761 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	762 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	763 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	764 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	765
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	766 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	767 * @param type the unresolved type of the constant
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	768 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	769 protected void handleUnresolvedLoadConstant(JavaType type) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	770 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	771 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	772 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	773
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	774 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	775 * @param type the unresolved type of the type check
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	776 * @param object the object value whose type is being checked against {@code type}
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	777 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	778 protected void handleUnresolvedCheckCast(JavaType type, ValueNode object) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	779 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	780 append(new FixedGuardNode(graph.unique(new IsNullNode(object)), Unresolved, InvalidateRecompile));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	781 frameState.push(Kind.Object, appendConstant(JavaConstant.NULL_POINTER));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	782 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	783
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	784 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	785 * @param type the unresolved type of the type check
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	786 * @param object the object value whose type is being checked against {@code type}
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	787 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	788 protected void handleUnresolvedInstanceOf(JavaType type, ValueNode object) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	789 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	790 AbstractBeginNode successor = graph.add(new BeginNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	791 DeoptimizeNode deopt = graph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	792 append(new IfNode(graph.unique(new IsNullNode(object)), successor, deopt, 1));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	793 lastInstr = successor;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	794 frameState.push(Kind.Int, appendConstant(JavaConstant.INT_0));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	795 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	796
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	797 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	798 * @param type the type being instantiated
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	799 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	800 protected void handleUnresolvedNewInstance(JavaType type) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	801 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	802 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	803 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	804
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	805 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	806 * @param type the type of the array being instantiated
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	807 * @param length the length of the array
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	808 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	809 protected void handleUnresolvedNewObjectArray(JavaType type, ValueNode length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	810 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	811 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	812 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	813
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	814 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	815 * @param type the type being instantiated
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	816 * @param dims the dimensions for the multi-array
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	817 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	818 protected void handleUnresolvedNewMultiArray(JavaType type, List<ValueNode> dims) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	819 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	820 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	821 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	822
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	823 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	824 * @param field the unresolved field
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	825 * @param receiver the object containing the field or {@code null} if {@code field} is static
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	826 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	827 protected void handleUnresolvedLoadField(JavaField field, ValueNode receiver) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	828 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	829 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	830 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	831
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	832 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	833 * @param field the unresolved field
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	834 * @param value the value being stored to the field
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	835 * @param receiver the object containing the field or {@code null} if {@code field} is static
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	836 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	837 protected void handleUnresolvedStoreField(JavaField field, ValueNode value, ValueNode receiver) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	838 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	839 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	840 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	841
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	842 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	843 * @param type
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	844 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	845 protected void handleUnresolvedExceptionType(JavaType type) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	846 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	847 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	848 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	849
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	850 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	851 * @param javaMethod
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	852 * @param invokeKind
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	853 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	854 protected void handleUnresolvedInvoke(JavaMethod javaMethod, InvokeKind invokeKind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	855 assert !graphBuilderConfig.eagerResolving();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	856 append(new DeoptimizeNode(InvalidateRecompile, Unresolved));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	857 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	858
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	859 private DispatchBeginNode handleException(ValueNode exceptionObject, int bci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	860 assert bci == BytecodeFrame.BEFORE_BCI \|\| bci == bci() : "invalid bci";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	861 Debug.log("Creating exception dispatch edges at %d, exception object=%s, exception seen=%s", bci, exceptionObject, (profilingInfo == null ? "" : profilingInfo.getExceptionSeen(bci)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	862
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	863 BciBlock dispatchBlock = currentBlock.exceptionDispatchBlock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	864 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	865 * The exception dispatch block is always for the last bytecode of a block, so if we are not
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	866 * at the endBci yet, there is no exception handler for this bci and we can unwind
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	867 * immediately.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	868 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	869 if (bci != currentBlock.endBci \|\| dispatchBlock == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	870 dispatchBlock = blockMap.getUnwindBlock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	871 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	872
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	873 FrameStateBuilder dispatchState = frameState.copy();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	874 dispatchState.clearStack();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	875
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	876 DispatchBeginNode dispatchBegin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	877 if (exceptionObject == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	878 dispatchBegin = graph.add(new ExceptionObjectNode(metaAccess));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	879 dispatchState.push(Kind.Object, dispatchBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	880 dispatchState.setRethrowException(true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	881 dispatchBegin.setStateAfter(dispatchState.create(bci, dispatchBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	882 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	883 dispatchBegin = graph.add(new DispatchBeginNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	884 dispatchState.push(Kind.Object, exceptionObject);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	885 dispatchBegin.setStateAfter(dispatchState.create(bci, dispatchBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	886 dispatchState.setRethrowException(true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	887 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	888 this.controlFlowSplit = true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	889 FixedNode target = createTarget(dispatchBlock, dispatchState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	890 FixedWithNextNode finishedDispatch = finishInstruction(dispatchBegin, dispatchState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	891 finishedDispatch.setNext(target);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	892 return dispatchBegin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	893 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	894
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	895 protected ValueNode genLoadIndexed(ValueNode array, ValueNode index, Kind kind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	896 return LoadIndexedNode.create(array, index, kind, metaAccess, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	897 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	898
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	899 protected void genStoreIndexed(ValueNode array, ValueNode index, Kind kind, ValueNode value) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	900 add(new StoreIndexedNode(array, index, kind, value));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	901 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	902
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	903 protected ValueNode genIntegerAdd(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	904 return AddNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	905 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	906
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	907 protected ValueNode genIntegerSub(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	908 return SubNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	909 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	910
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	911 protected ValueNode genIntegerMul(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	912 return MulNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	913 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	914
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	915 protected ValueNode genFloatAdd(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	916 return AddNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	917 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	918
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	919 protected ValueNode genFloatSub(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	920 return SubNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	921 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	922
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	923 protected ValueNode genFloatMul(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	924 return MulNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	925 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	926
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	927 protected ValueNode genFloatDiv(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	928 return DivNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	929 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	930
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	931 protected ValueNode genFloatRem(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	932 return new RemNode(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	933 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	934
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	935 protected ValueNode genIntegerDiv(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	936 return new IntegerDivNode(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	937 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	938
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	939 protected ValueNode genIntegerRem(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	940 return new IntegerRemNode(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	941 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	942
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	943 protected ValueNode genNegateOp(ValueNode x) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	944 return (new NegateNode(x));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	945 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	946
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	947 protected ValueNode genLeftShift(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	948 return new LeftShiftNode(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	949 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	950
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	951 protected ValueNode genRightShift(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	952 return new RightShiftNode(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	953 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	954
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	955 protected ValueNode genUnsignedRightShift(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	956 return new UnsignedRightShiftNode(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	957 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	958
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	959 protected ValueNode genAnd(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	960 return AndNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	961 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	962
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	963 protected ValueNode genOr(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	964 return OrNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	965 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	966
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	967 protected ValueNode genXor(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	968 return XorNode.create(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	969 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	970
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	971 protected ValueNode genNormalizeCompare(ValueNode x, ValueNode y, boolean isUnorderedLess) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	972 return NormalizeCompareNode.create(x, y, isUnorderedLess, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	973 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	974
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	975 protected ValueNode genFloatConvert(FloatConvert op, ValueNode input) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	976 return FloatConvertNode.create(op, input);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	977 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	978
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	979 protected ValueNode genNarrow(ValueNode input, int bitCount) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	980 return NarrowNode.create(input, bitCount);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	981 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	982
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	983 protected ValueNode genSignExtend(ValueNode input, int bitCount) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	984 return SignExtendNode.create(input, bitCount);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	985 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	986
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	987 protected ValueNode genZeroExtend(ValueNode input, int bitCount) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	988 return ZeroExtendNode.create(input, bitCount);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	989 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	990
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	991 protected void genGoto() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	992 appendGoto(currentBlock.getSuccessor(0));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	993 assert currentBlock.numNormalSuccessors() == 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	994 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	995
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	996 protected LogicNode genObjectEquals(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	997 return ObjectEqualsNode.create(x, y, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	998 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	999
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1000 protected LogicNode genIntegerEquals(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1001 return IntegerEqualsNode.create(x, y, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1002 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1003
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1004 protected LogicNode genIntegerLessThan(ValueNode x, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1005 return IntegerLessThanNode.create(x, y, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1006 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1007
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1008 protected ValueNode genUnique(ValueNode x) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1009 return (ValueNode) graph.unique((Node & ValueNumberable) x);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1010 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1011
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1012 protected ValueNode genIfNode(LogicNode condition, FixedNode falseSuccessor, FixedNode trueSuccessor, double d) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1013 return new IfNode(condition, falseSuccessor, trueSuccessor, d);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1014 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1015
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1016 protected void genThrow() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1017 ValueNode exception = frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1018 append(new FixedGuardNode(graph.unique(new IsNullNode(exception)), NullCheckException, InvalidateReprofile, true));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1019 lastInstr.setNext(handleException(exception, bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1020 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1021
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1022 protected ValueNode createCheckCast(ResolvedJavaType type, ValueNode object, JavaTypeProfile profileForTypeCheck, boolean forStoreCheck) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1023 return CheckCastNode.create(type, object, profileForTypeCheck, forStoreCheck, graph.getAssumptions());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1024 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1025
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1026 protected ValueNode createInstanceOf(ResolvedJavaType type, ValueNode object, JavaTypeProfile profileForTypeCheck) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1027 return InstanceOfNode.create(type, object, profileForTypeCheck);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1028 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1029
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1030 protected ValueNode genConditional(ValueNode x) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1031 return new ConditionalNode((LogicNode) x);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1032 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1033
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1034 protected NewInstanceNode createNewInstance(ResolvedJavaType type, boolean fillContents) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1035 return new NewInstanceNode(type, fillContents);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1036 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1037
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1038 protected NewArrayNode createNewArray(ResolvedJavaType elementType, ValueNode length, boolean fillContents) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1039 return new NewArrayNode(elementType, length, fillContents);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1040 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1041
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1042 protected NewMultiArrayNode createNewMultiArray(ResolvedJavaType type, List<ValueNode> dimensions) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1043 return new NewMultiArrayNode(type, dimensions.toArray(new ValueNode[0]));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1044 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1045
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1046 protected ValueNode genLoadField(ValueNode receiver, ResolvedJavaField field) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1047 return new LoadFieldNode(receiver, field);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1048 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1049
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1050 protected ValueNode emitExplicitNullCheck(ValueNode receiver) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1051 if (StampTool.isPointerNonNull(receiver.stamp())) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1052 return receiver;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1053 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1054 BytecodeExceptionNode exception = graph.add(new BytecodeExceptionNode(metaAccess, NullPointerException.class));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1055 AbstractBeginNode falseSucc = graph.add(new BeginNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1056 PiNode nonNullReceiver = graph.unique(new PiNode(receiver, receiver.stamp().join(objectNonNull())));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1057 nonNullReceiver.setGuard(falseSucc);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1058 append(new IfNode(graph.unique(new IsNullNode(receiver)), exception, falseSucc, 0.01));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1059 lastInstr = falseSucc;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1060
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1061 exception.setStateAfter(createFrameState(bci(), exception));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1062 exception.setNext(handleException(exception, bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1063 return nonNullReceiver;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1064 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1065
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1066 protected void emitExplicitBoundsCheck(ValueNode index, ValueNode length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1067 AbstractBeginNode trueSucc = graph.add(new BeginNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1068 BytecodeExceptionNode exception = graph.add(new BytecodeExceptionNode(metaAccess, ArrayIndexOutOfBoundsException.class, index));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1069 append(new IfNode(graph.unique(IntegerBelowNode.create(index, length, constantReflection)), trueSucc, exception, 0.99));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1070 lastInstr = trueSucc;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1071
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1072 exception.setStateAfter(createFrameState(bci(), exception));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1073 exception.setNext(handleException(exception, bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1074 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1075
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1076 protected ValueNode genArrayLength(ValueNode x) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1077 return ArrayLengthNode.create(x, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1078 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1079
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1080 protected void genStoreField(ValueNode receiver, ResolvedJavaField field, ValueNode value) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1081 StoreFieldNode storeFieldNode = new StoreFieldNode(receiver, field, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1082 append(storeFieldNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1083 storeFieldNode.setStateAfter(this.createFrameState(stream.nextBCI(), storeFieldNode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1084 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1085
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1086 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1087 * Ensure that concrete classes are at least linked before generating an invoke. Interfaces may
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1088 * never be linked so simply return true for them.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1089 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1090 * @param target
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1091 * @return true if the declared holder is an interface or is linked
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1092 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1093 private static boolean callTargetIsResolved(JavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1094 if (target instanceof ResolvedJavaMethod) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1095 ResolvedJavaMethod resolvedTarget = (ResolvedJavaMethod) target;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1096 ResolvedJavaType resolvedType = resolvedTarget.getDeclaringClass();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1097 return resolvedType.isInterface() \|\| resolvedType.isLinked();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1098 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1099 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1100 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1101
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1102 protected void genInvokeStatic(JavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1103 if (callTargetIsResolved(target)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1104 ResolvedJavaMethod resolvedTarget = (ResolvedJavaMethod) target;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1105 ResolvedJavaType holder = resolvedTarget.getDeclaringClass();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1106 if (!holder.isInitialized() && ResolveClassBeforeStaticInvoke.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1107 handleUnresolvedInvoke(target, InvokeKind.Static);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1108 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1109 ValueNode[] args = frameState.popArguments(resolvedTarget.getSignature().getParameterCount(false));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1110 appendInvoke(InvokeKind.Static, resolvedTarget, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1111 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1112 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1113 handleUnresolvedInvoke(target, InvokeKind.Static);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1114 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1115 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1116
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1117 protected void genInvokeInterface(JavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1118 if (callTargetIsResolved(target)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1119 ValueNode[] args = frameState.popArguments(target.getSignature().getParameterCount(true));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1120 appendInvoke(InvokeKind.Interface, (ResolvedJavaMethod) target, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1121 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1122 handleUnresolvedInvoke(target, InvokeKind.Interface);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1123 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1124 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1125
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1126 protected void genInvokeDynamic(JavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1127 if (target instanceof ResolvedJavaMethod) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1128 JavaConstant appendix = constantPool.lookupAppendix(stream.readCPI4(), Bytecodes.INVOKEDYNAMIC);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1129 if (appendix != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1130 frameState.push(Kind.Object, ConstantNode.forConstant(appendix, metaAccess, graph));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1131 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1132 ValueNode[] args = frameState.popArguments(target.getSignature().getParameterCount(false));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1133 appendInvoke(InvokeKind.Static, (ResolvedJavaMethod) target, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1134 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1135 handleUnresolvedInvoke(target, InvokeKind.Static);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1136 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1137 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1138
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1139 protected void genInvokeVirtual(JavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1140 if (callTargetIsResolved(target)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1141 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1142 * Special handling for runtimes that rewrite an invocation of MethodHandle.invoke(...)
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1143 * or MethodHandle.invokeExact(...) to a static adapter. HotSpot does this - see
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1144 * https://wikis.oracle.com/display/HotSpotInternals/Method+handles +and+invokedynamic
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1145 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1146 boolean hasReceiver = !((ResolvedJavaMethod) target).isStatic();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1147 JavaConstant appendix = constantPool.lookupAppendix(stream.readCPI(), Bytecodes.INVOKEVIRTUAL);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1148 if (appendix != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1149 frameState.push(Kind.Object, ConstantNode.forConstant(appendix, metaAccess, graph));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1150 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1151 ValueNode[] args = frameState.popArguments(target.getSignature().getParameterCount(hasReceiver));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1152 if (hasReceiver) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1153 appendInvoke(InvokeKind.Virtual, (ResolvedJavaMethod) target, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1154 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1155 appendInvoke(InvokeKind.Static, (ResolvedJavaMethod) target, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1156 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1157 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1158 handleUnresolvedInvoke(target, InvokeKind.Virtual);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1159 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1160
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1161 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1162
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1163 protected void genInvokeSpecial(JavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1164 if (callTargetIsResolved(target)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1165 assert target != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1166 assert target.getSignature() != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1167 ValueNode[] args = frameState.popArguments(target.getSignature().getParameterCount(true));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1168 appendInvoke(InvokeKind.Special, (ResolvedJavaMethod) target, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1169 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1170 handleUnresolvedInvoke(target, InvokeKind.Special);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1171 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1172 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1173
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1174 private InvokeKind currentInvokeKind;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1175 private JavaType currentInvokeReturnType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1176 protected FrameStateBuilder frameState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1177 protected BciBlock currentBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1178 protected final BytecodeStream stream;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1179 protected final GraphBuilderConfiguration graphBuilderConfig;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1180 protected final ResolvedJavaMethod method;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1181 protected final ProfilingInfo profilingInfo;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1182 protected final OptimisticOptimizations optimisticOpts;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1183 protected final ConstantPool constantPool;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1184 protected final MetaAccessProvider metaAccess;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1185 private final ConstantReflectionProvider constantReflection;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1186 private final StampProvider stampProvider;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1187 protected final IntrinsicContext intrinsicContext;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1188
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1189 public InvokeKind getInvokeKind() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1190 return currentInvokeKind;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1191 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1192
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1193 public JavaType getInvokeReturnType() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1194 return currentInvokeReturnType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1195 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1196
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1197 public void handleReplacedInvoke(InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1198 appendInvoke(invokeKind, targetMethod, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1199 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1200
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1201 private void appendInvoke(InvokeKind initialInvokeKind, ResolvedJavaMethod initialTargetMethod, ValueNode[] args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1202 ResolvedJavaMethod targetMethod = initialTargetMethod;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1203 InvokeKind invokeKind = initialInvokeKind;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1204 if (initialInvokeKind.isIndirect()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1205 ResolvedJavaType contextType = this.frameState.getMethod().getDeclaringClass();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1206 ResolvedJavaMethod specialCallTarget = MethodCallTargetNode.findSpecialCallTarget(initialInvokeKind, args[0], initialTargetMethod, contextType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1207 if (specialCallTarget != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1208 invokeKind = InvokeKind.Special;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1209 targetMethod = specialCallTarget;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1210 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1211 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1212
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1213 Kind resultType = targetMethod.getSignature().getReturnKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1214 if (DeoptALot.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1215 append(new DeoptimizeNode(DeoptimizationAction.None, RuntimeConstraint));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1216 frameState.pushReturn(resultType, ConstantNode.defaultForKind(resultType, graph));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1217 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1218 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1219
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1220 JavaType returnType = targetMethod.getSignature().getReturnType(method.getDeclaringClass());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1221 if (graphBuilderConfig.eagerResolving() \|\| parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1222 returnType = returnType.resolve(targetMethod.getDeclaringClass());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1223 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1224 if (invokeKind.hasReceiver()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1225 args[0] = emitExplicitExceptions(args[0], null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1226 if (invokeKind.isIndirect() && profilingInfo != null && this.optimisticOpts.useTypeCheckHints()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1227 JavaTypeProfile profile = profilingInfo.getTypeProfile(bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1228 args[0] = TypeProfileProxyNode.proxify(args[0], profile);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1229 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1230
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1231 if (args[0].isNullConstant()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1232 append(new DeoptimizeNode(InvalidateRecompile, NullCheckException));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1233 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1234 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1235 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1236
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1237 try {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1238 currentInvokeReturnType = returnType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1239 currentInvokeKind = invokeKind;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1240 if (tryGenericInvocationPlugin(args, targetMethod)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1241 if (TraceParserPlugins.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1242 traceWithContext("used generic invocation plugin for %s", targetMethod.format("%h.%n(%p)"));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1243 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1244 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1245 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1246
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1247 if (invokeKind.isDirect()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1248 if (tryInvocationPlugin(args, targetMethod, resultType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1249 if (TraceParserPlugins.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1250 traceWithContext("used invocation plugin for %s", targetMethod.format("%h.%n(%p)"));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1251 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1252 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1253 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1254
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1255 if (tryInline(args, targetMethod, returnType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1256 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1257 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1258 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1259 } finally {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1260 currentInvokeReturnType = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1261 currentInvokeKind = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1262 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1263
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1264 MethodCallTargetNode callTarget = graph.add(createMethodCallTarget(invokeKind, targetMethod, args, returnType));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1265
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1266 // be conservative if information was not recorded (could result in endless
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1267 // recompiles otherwise)
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1268 Invoke invoke;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1269 if (graphBuilderConfig.omitAllExceptionEdges() \|\|
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1270 (!StressInvokeWithExceptionNode.getValue() && optimisticOpts.useExceptionProbability() && profilingInfo != null && profilingInfo.getExceptionSeen(bci()) == TriState.FALSE)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1271 invoke = createInvoke(callTarget, resultType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1272 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1273 invoke = createInvokeWithException(callTarget, resultType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1274 AbstractBeginNode beginNode = graph.add(new KillingBeginNode(LocationIdentity.any()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1275 invoke.setNext(beginNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1276 lastInstr = beginNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1277 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1278
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1279 for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1280 plugin.notifyNotInlined(this, targetMethod, invoke);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1281 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1282 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1283
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1284 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1285 * Contains all the assertion checking logic around the application of an
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1286 * {@link InvocationPlugin}. This class is only loaded when assertions are enabled.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1287 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1288 class InvocationPluginAssertions {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1289 final InvocationPlugin plugin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1290 final ValueNode[] args;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1291 final ResolvedJavaMethod targetMethod;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1292 final Kind resultType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1293 final int beforeStackSize;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1294 final boolean needsNullCheck;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1295 final int nodeCount;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1296 final Mark mark;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1297
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1298 public InvocationPluginAssertions(InvocationPlugin plugin, ValueNode[] args, ResolvedJavaMethod targetMethod, Kind resultType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1299 guarantee(assertionsEnabled(), "%s should only be loaded and instantiated if assertions are enabled", getClass().getSimpleName());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1300 this.plugin = plugin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1301 this.targetMethod = targetMethod;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1302 this.args = args;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1303 this.resultType = resultType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1304 this.beforeStackSize = frameState.stackSize();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1305 this.needsNullCheck = !targetMethod.isStatic() && args[0].getKind() == Kind.Object && !StampTool.isPointerNonNull(args[0].stamp());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1306 this.nodeCount = graph.getNodeCount();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1307 this.mark = graph.getMark();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1308 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1309
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1310 String error(String format, Object... a) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1311 return String.format(format, a) + String.format("%n\tplugin at %s", plugin.getApplySourceLocation(metaAccess));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1312 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1313
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1314 boolean check(boolean pluginResult) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1315 if (pluginResult == true) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1316 int expectedStackSize = beforeStackSize + resultType.getSlotCount();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1317 assert expectedStackSize == frameState.stackSize() : error("plugin manipulated the stack incorrectly: expected=%d, actual=%d", expectedStackSize, frameState.stackSize());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1318 NodeIterable<Node> newNodes = graph.getNewNodes(mark);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1319 assert !needsNullCheck \|\| isPointerNonNull(args[0].stamp()) : error("plugin needs to null check the receiver of %s: receiver=%s", targetMethod.format("%H.%n(%p)"), args[0]);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1320 for (Node n : newNodes) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1321 if (n instanceof StateSplit) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1322 StateSplit stateSplit = (StateSplit) n;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1323 assert stateSplit.stateAfter() != null \|\| !stateSplit.hasSideEffect() : error("%s node added by plugin for %s need to have a non-null frame state: %s",
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1324 StateSplit.class.getSimpleName(), targetMethod.format("%H.%n(%p)"), stateSplit);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1325 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1326 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1327 try {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1328 graphBuilderConfig.getPlugins().getInvocationPlugins().checkNewNodes(BytecodeParser.this, plugin, newNodes);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1329 } catch (Throwable t) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1330 throw new AssertionError(error("Error in plugin"), t);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1331 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1332 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1333 assert nodeCount == graph.getNodeCount() : error("plugin that returns false must not create new nodes");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1334 assert beforeStackSize == frameState.stackSize() : error("plugin that returns false must not modify the stack");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1335 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1336 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1337 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1338 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1339
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1340 private boolean tryInvocationPlugin(ValueNode[] args, ResolvedJavaMethod targetMethod, Kind resultType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1341 InvocationPlugin plugin = graphBuilderConfig.getPlugins().getInvocationPlugins().lookupInvocation(targetMethod);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1342 if (plugin != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1343
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1344 if (intrinsicContext != null && intrinsicContext.isCallToOriginal(targetMethod)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1345 // Self recursive intrinsic means the original
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1346 // method should be called.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1347 assert !targetMethod.hasBytecodes() : "TODO: when does this happen?";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1348 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1349 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1350
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1351 InvocationPluginAssertions assertions = assertionsEnabled() ? new InvocationPluginAssertions(plugin, args, targetMethod, resultType) : null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1352 if (plugin.execute(this, targetMethod, invocationPluginReceiver.init(targetMethod, args), args)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1353 assert assertions.check(true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1354 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1355 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1356 assert assertions.check(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1357 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1358 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1359 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1360
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1361 private boolean tryGenericInvocationPlugin(ValueNode[] args, ResolvedJavaMethod targetMethod) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1362 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1363 if (plugin.handleInvoke(this, targetMethod, args)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1364 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1365 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1366 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1367 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1368 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1369
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1370 private boolean tryInline(ValueNode[] args, ResolvedJavaMethod targetMethod, JavaType returnType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1371 boolean canBeInlined = parsingIntrinsic() \|\| targetMethod.canBeInlined();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1372 if (!canBeInlined) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1373 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1374 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1375 for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1376 InlineInfo inlineInfo = plugin.shouldInlineInvoke(this, targetMethod, args, returnType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1377 if (inlineInfo != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1378 if (inlineInfo.getMethodToInline() == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1379 /* Do not inline, and do not ask the remaining plugins. */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1380 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1381 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1382 return inline(targetMethod, inlineInfo.getMethodToInline(), inlineInfo.isIntrinsic(), args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1383 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1384 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1385 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1386 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1387 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1388
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1389 public void intrinsify(ResolvedJavaMethod targetMethod, ResolvedJavaMethod substitute, ValueNode[] args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1390 boolean res = inline(targetMethod, substitute, true, args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1391 assert res : "failed to inline " + substitute;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1392 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1393
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1394 private boolean inline(ResolvedJavaMethod targetMethod, ResolvedJavaMethod inlinedMethod, boolean isIntrinsic, ValueNode[] args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1395 if (TraceInlineDuringParsing.getValue() \|\| TraceParserPlugins.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1396 if (targetMethod.equals(inlinedMethod)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1397 traceWithContext("inlining call to %s", inlinedMethod.format("%h.%n(%p)"));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1398 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1399 traceWithContext("inlining call to %s as intrinsic for %s", inlinedMethod.format("%h.%n(%p)"), targetMethod.format("%h.%n(%p)"));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1400 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1401 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1402 IntrinsicContext intrinsic = this.intrinsicContext;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1403 if (intrinsic != null && intrinsic.isCallToOriginal(targetMethod)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1404 if (intrinsic.isCompilationRoot()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1405 // A root compiled intrinsic needs to deoptimize
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1406 // if the slow path is taken. During frame state
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1407 // assignment, the deopt node will get its stateBefore
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1408 // from the start node of the intrinsic
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1409 append(new DeoptimizeNode(InvalidateRecompile, RuntimeConstraint));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1410 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1411 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1412 // Otherwise inline the original method. Any frame state created
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1413 // during the inlining will exclude frame(s) in the
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1414 // intrinsic method (see HIRFrameStateBuilder.create(int bci)).
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1415 if (intrinsic.getOriginalMethod().isNative()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1416 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1417 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1418 parseAndInlineCallee(intrinsic.getOriginalMethod(), args, null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1419 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1420 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1421 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1422 if (intrinsic == null && isIntrinsic) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1423 assert !inlinedMethod.equals(targetMethod);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1424 intrinsic = new IntrinsicContext(targetMethod, inlinedMethod, INLINE_DURING_PARSING);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1425 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1426 if (inlinedMethod.hasBytecodes()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1427 for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1428 plugin.notifyBeforeInline(targetMethod);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1429 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1430 parseAndInlineCallee(inlinedMethod, args, intrinsic);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1431 for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1432 plugin.notifyAfterInline(targetMethod);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1433 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1434 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1435 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1436 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1437 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1438 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1439 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1440
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1441 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1442 * Prints a line to {@link TTY} with a prefix indicating the current parse context. The prefix
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1443 * is of the form:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1444 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1445 * <pre>
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1446 * {SPACE * n} {name of method being parsed} "(" {file name} ":" {line number} ")"
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1447 * </pre>
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1448 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1449 * where {@code n} is the current inlining depth.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1450 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1451 * @param format a format string
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1452 * @param args arguments to the format string
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1453 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1454
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1455 protected void traceWithContext(String format, Object... args) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1456 StackTraceElement where = method.asStackTraceElement(bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1457 TTY.println(format("%s%s (%s:%d) %s", nSpaces(getDepth()), method.isConstructor() ? method.format("%h.%n") : method.getName(), where.getFileName(), where.getLineNumber(), format(format, args)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1458 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1459
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1460 protected BytecodeParserError asParserError(Throwable e) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1461 if (e instanceof BytecodeParserError) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1462 return (BytecodeParserError) e;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1463 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1464 BytecodeParser bp = this;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1465 BytecodeParserError res = new BytecodeParserError(e);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1466 while (bp != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1467 res.addContext("parsing " + bp.method.asStackTraceElement(bp.bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1468 bp = bp.parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1469 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1470 return res;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1471 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1472
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1473 private void parseAndInlineCallee(ResolvedJavaMethod targetMethod, ValueNode[] args, IntrinsicContext calleeIntrinsicContext) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1474 try (IntrinsicScope s = calleeIntrinsicContext != null && !parsingIntrinsic() ? new IntrinsicScope(this, targetMethod.getSignature().toParameterKinds(!targetMethod.isStatic()), args) : null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1475
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1476 BytecodeParser parser = graphBuilderInstance.createBytecodeParser(graph, this, targetMethod, INVOCATION_ENTRY_BCI, calleeIntrinsicContext);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1477 FrameStateBuilder startFrameState = new FrameStateBuilder(parser, targetMethod, graph);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1478 if (!targetMethod.isStatic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1479 args[0] = nullCheckedValue(args[0]);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1480 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1481 startFrameState.initializeFromArgumentsArray(args);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1482 parser.build(this.lastInstr, startFrameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1483
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1484 FixedWithNextNode calleeBeforeReturnNode = parser.getBeforeReturnNode();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1485 this.lastInstr = calleeBeforeReturnNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1486 Kind calleeReturnKind = targetMethod.getSignature().getReturnKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1487 if (calleeBeforeReturnNode != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1488 ValueNode calleeReturnValue = parser.getReturnValue();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1489 if (calleeReturnValue != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1490 frameState.push(calleeReturnKind.getStackKind(), calleeReturnValue);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1491 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1492 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1493
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1494 FixedWithNextNode calleeBeforeUnwindNode = parser.getBeforeUnwindNode();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1495 if (calleeBeforeUnwindNode != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1496 ValueNode calleeUnwindValue = parser.getUnwindValue();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1497 assert calleeUnwindValue != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1498 calleeBeforeUnwindNode.setNext(handleException(calleeUnwindValue, bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1499 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1500
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1501 // Record inlined method dependency in the graph
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1502 graph.recordInlinedMethod(targetMethod);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1503 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1504 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1505
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1506 protected MethodCallTargetNode createMethodCallTarget(InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] args, JavaType returnType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1507 return new MethodCallTargetNode(invokeKind, targetMethod, args, returnType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1508 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1509
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1510 protected InvokeNode createInvoke(CallTargetNode callTarget, Kind resultType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1511 InvokeNode invoke = append(new InvokeNode(callTarget, bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1512 frameState.pushReturn(resultType, invoke);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1513 invoke.setStateAfter(createFrameState(stream.nextBCI(), invoke));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1514 return invoke;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1515 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1516
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1517 protected InvokeWithExceptionNode createInvokeWithException(CallTargetNode callTarget, Kind resultType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1518 if (currentBlock != null && stream.nextBCI() > currentBlock.endBci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1519 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1520 * Clear non-live locals early so that the exception handler entry gets the cleared
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1521 * state.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1522 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1523 frameState.clearNonLiveLocals(currentBlock, liveness, false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1524 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1525
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1526 DispatchBeginNode exceptionEdge = handleException(null, bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1527 InvokeWithExceptionNode invoke = append(new InvokeWithExceptionNode(callTarget, exceptionEdge, bci()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1528 frameState.pushReturn(resultType, invoke);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1529 invoke.setStateAfter(createFrameState(stream.nextBCI(), invoke));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1530 return invoke;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1531 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1532
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1533 protected void genReturn(ValueNode returnVal, Kind returnKind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1534 if (parsingIntrinsic() && returnVal != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1535 if (returnVal instanceof StateSplit) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1536 StateSplit stateSplit = (StateSplit) returnVal;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1537 FrameState stateAfter = stateSplit.stateAfter();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1538 if (stateSplit.hasSideEffect()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1539 assert stateSplit != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1540 if (stateAfter.bci == BytecodeFrame.AFTER_BCI) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1541 assert stateAfter.usages().count() == 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1542 assert stateAfter.usages().first() == stateSplit;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1543 stateAfter.replaceAtUsages(graph.add(new FrameState(BytecodeFrame.AFTER_BCI, returnVal)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1544 GraphUtil.killWithUnusedFloatingInputs(stateAfter);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1545 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1546 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1547 * This must be the return value from within a partial intrinsification.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1548 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1549 assert !BytecodeFrame.isPlaceholderBci(stateAfter.bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1550 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1551 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1552 assert stateAfter == null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1553 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1554 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1555 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1556 if (parent == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1557 frameState.setRethrowException(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1558 frameState.clearStack();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1559 beforeReturn(returnVal, returnKind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1560 append(new ReturnNode(returnVal));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1561 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1562 if (blockMap.getReturnCount() == 1 \|\| !controlFlowSplit) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1563 // There is only a single return.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1564 beforeReturn(returnVal, returnKind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1565 this.returnValue = returnVal;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1566 this.beforeReturnNode = this.lastInstr;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1567 this.lastInstr = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1568 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1569 frameState.setRethrowException(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1570 frameState.clearStack();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1571 if (returnVal != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1572 frameState.push(returnKind, returnVal);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1573 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1574 assert blockMap.getReturnCount() > 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1575 appendGoto(blockMap.getReturnBlock());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1576 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1577 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1578 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1579
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1580 private void beforeReturn(ValueNode x, Kind kind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1581 if (graph.method() != null && graph.method().isJavaLangObjectInit()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1582 append(new RegisterFinalizerNode(frameState.loadLocal(0, Kind.Object)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1583 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1584 if (graphBuilderConfig.insertNonSafepointDebugInfo() && !parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1585 append(createInfoPointNode(InfopointReason.METHOD_END));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1586 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1587
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1588 synchronizedEpilogue(BytecodeFrame.AFTER_BCI, x, kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1589 if (frameState.lockDepth() != 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1590 throw bailout("unbalanced monitors");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1591 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1592 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1593
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1594 protected void genMonitorEnter(ValueNode x, int bci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1595 MonitorIdNode monitorId = graph.add(new MonitorIdNode(frameState.lockDepth()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1596 MonitorEnterNode monitorEnter = append(new MonitorEnterNode(x, monitorId));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1597 frameState.pushLock(x, monitorId);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1598 monitorEnter.setStateAfter(createFrameState(bci, monitorEnter));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1599 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1600
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1601 protected void genMonitorExit(ValueNode x, ValueNode escapedReturnValue, int bci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1602 MonitorIdNode monitorId = frameState.peekMonitorId();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1603 ValueNode lockedObject = frameState.popLock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1604 if (GraphUtil.originalValue(lockedObject) != GraphUtil.originalValue(x)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1605 throw bailout(String.format("unbalanced monitors: mismatch at monitorexit, %s != %s", GraphUtil.originalValue(x), GraphUtil.originalValue(lockedObject)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1606 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1607 MonitorExitNode monitorExit = append(new MonitorExitNode(x, monitorId, escapedReturnValue));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1608 monitorExit.setStateAfter(createFrameState(bci, monitorExit));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1609 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1610
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1611 protected void genJsr(int dest) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1612 BciBlock successor = currentBlock.getJsrSuccessor();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1613 assert successor.startBci == dest : successor.startBci + " != " + dest + " @" + bci();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1614 JsrScope scope = currentBlock.getJsrScope();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1615 int nextBci = getStream().nextBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1616 if (!successor.getJsrScope().pop().equals(scope)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1617 throw new JsrNotSupportedBailout("unstructured control flow (internal limitation)");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1618 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1619 if (successor.getJsrScope().nextReturnAddress() != nextBci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1620 throw new JsrNotSupportedBailout("unstructured control flow (internal limitation)");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1621 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1622 ConstantNode nextBciNode = getJsrConstant(nextBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1623 frameState.push(Kind.Object, nextBciNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1624 appendGoto(successor);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1625 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1626
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1627 protected void genRet(int localIndex) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1628 BciBlock successor = currentBlock.getRetSuccessor();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1629 ValueNode local = frameState.loadLocal(localIndex, Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1630 JsrScope scope = currentBlock.getJsrScope();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1631 int retAddress = scope.nextReturnAddress();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1632 ConstantNode returnBciNode = getJsrConstant(retAddress);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1633 LogicNode guard = IntegerEqualsNode.create(local, returnBciNode, constantReflection);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1634 guard = graph.unique(guard);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1635 append(new FixedGuardNode(guard, JavaSubroutineMismatch, InvalidateReprofile));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1636 if (!successor.getJsrScope().equals(scope.pop())) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1637 throw new JsrNotSupportedBailout("unstructured control flow (ret leaves more than one scope)");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1638 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1639 appendGoto(successor);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1640 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1641
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1642 private ConstantNode getJsrConstant(long bci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1643 JavaConstant nextBciConstant = new RawConstant(bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1644 Stamp nextBciStamp = StampFactory.forConstant(nextBciConstant);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1645 ConstantNode nextBciNode = new ConstantNode(nextBciConstant, nextBciStamp);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1646 return graph.unique(nextBciNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1647 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1648
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1649 protected void genIntegerSwitch(ValueNode value, ArrayList<BciBlock> actualSuccessors, int[] keys, double[] keyProbabilities, int[] keySuccessors) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1650 if (value.isConstant()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1651 JavaConstant constant = (JavaConstant) value.asConstant();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1652 int constantValue = constant.asInt();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1653 for (int i = 0; i < keys.length; ++i) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1654 if (keys[i] == constantValue) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1655 appendGoto(actualSuccessors.get(keySuccessors[i]));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1656 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1657 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1658 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1659 appendGoto(actualSuccessors.get(keySuccessors[keys.length]));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1660 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1661 this.controlFlowSplit = true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1662 double[] successorProbabilities = successorProbabilites(actualSuccessors.size(), keySuccessors, keyProbabilities);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1663 IntegerSwitchNode switchNode = append(new IntegerSwitchNode(value, actualSuccessors.size(), keys, keyProbabilities, keySuccessors));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1664 for (int i = 0; i < actualSuccessors.size(); i++) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1665 switchNode.setBlockSuccessor(i, createBlockTarget(successorProbabilities[i], actualSuccessors.get(i), frameState));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1666 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1667 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1668 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1669
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1670 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1671 * Helper function that sums up the probabilities of all keys that lead to a specific successor.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1672 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1673 * @return an array of size successorCount with the accumulated probability for each successor.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1674 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1675 private static double[] successorProbabilites(int successorCount, int[] keySuccessors, double[] keyProbabilities) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1676 double[] probability = new double[successorCount];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1677 for (int i = 0; i < keySuccessors.length; i++) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1678 probability[keySuccessors[i]] += keyProbabilities[i];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1679 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1680 return probability;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1681 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1682
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1683 protected ConstantNode appendConstant(JavaConstant constant) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1684 assert constant != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1685 return ConstantNode.forConstant(constant, metaAccess, graph);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1686 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1687
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1688 @Override
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1689 public <T extends ValueNode> T append(T v) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1690 if (v.graph() != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1691 return v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1692 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1693 T added = graph.addOrUnique(v);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1694 if (added == v) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1695 updateLastInstruction(v);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1696 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1697 return added;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1698 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1699
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1700 public <T extends ValueNode> T recursiveAppend(T v) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1701 if (v.graph() != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1702 return v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1703 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1704 T added = graph.addOrUniqueWithInputs(v);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1705 if (added == v) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1706 updateLastInstruction(v);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1707 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1708 return added;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1709 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1710
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1711 private <T extends ValueNode> void updateLastInstruction(T v) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1712 if (v instanceof FixedNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1713 FixedNode fixedNode = (FixedNode) v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1714 lastInstr.setNext(fixedNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1715 if (fixedNode instanceof FixedWithNextNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1716 FixedWithNextNode fixedWithNextNode = (FixedWithNextNode) fixedNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1717 assert fixedWithNextNode.next() == null : "cannot append instruction to instruction which isn't end";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1718 lastInstr = fixedWithNextNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1719 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1720 lastInstr = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1721 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1722 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1723 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1724
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1725 private Target checkLoopExit(FixedNode target, BciBlock targetBlock, FrameStateBuilder state) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1726 if (currentBlock != null && !explodeLoops) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1727 long exits = currentBlock.loops & ~targetBlock.loops;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1728 if (exits != 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1729 LoopExitNode firstLoopExit = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1730 LoopExitNode lastLoopExit = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1731
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1732 int pos = 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1733 ArrayList<BciBlock> exitLoops = new ArrayList<>(Long.bitCount(exits));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1734 do {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1735 long lMask = 1L << pos;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1736 if ((exits & lMask) != 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1737 exitLoops.add(blockMap.getLoopHeader(pos));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1738 exits &= ~lMask;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1739 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1740 pos++;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1741 } while (exits != 0);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1742
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1743 Collections.sort(exitLoops, new Comparator<BciBlock>() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1744
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1745 @Override
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1746 public int compare(BciBlock o1, BciBlock o2) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1747 return Long.bitCount(o2.loops) - Long.bitCount(o1.loops);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1748 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1749 });
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1750
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1751 int bci = targetBlock.startBci;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1752 if (targetBlock instanceof ExceptionDispatchBlock) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1753 bci = ((ExceptionDispatchBlock) targetBlock).deoptBci;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1754 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1755 FrameStateBuilder newState = state.copy();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1756 for (BciBlock loop : exitLoops) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1757 LoopBeginNode loopBegin = (LoopBeginNode) getFirstInstruction(loop, this.getCurrentDimension());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1758 LoopExitNode loopExit = graph.add(new LoopExitNode(loopBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1759 if (lastLoopExit != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1760 lastLoopExit.setNext(loopExit);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1761 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1762 if (firstLoopExit == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1763 firstLoopExit = loopExit;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1764 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1765 lastLoopExit = loopExit;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1766 Debug.log("Target %s Exits %s, scanning framestates...", targetBlock, loop);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1767 newState.insertLoopProxies(loopExit, getEntryState(loop, this.getCurrentDimension()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1768 loopExit.setStateAfter(newState.create(bci, loopExit));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1769 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1770
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1771 lastLoopExit.setNext(target);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1772 return new Target(firstLoopExit, newState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1773 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1774 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1775 return new Target(target, state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1776 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1777
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1778 private FrameStateBuilder getEntryState(BciBlock block, int dimension) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1779 int id = block.id;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1780 if (dimension == 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1781 return entryStateArray[id];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1782 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1783 return getEntryStateMultiDimension(dimension, id);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1784 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1785 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1786
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1787 private FrameStateBuilder getEntryStateMultiDimension(int dimension, int id) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1788 if (entryStateMatrix != null && dimension - 1 < entryStateMatrix.length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1789 FrameStateBuilder[] entryStateArrayEntry = entryStateMatrix[dimension - 1];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1790 if (entryStateArrayEntry == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1791 return null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1792 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1793 return entryStateArrayEntry[id];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1794 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1795 return null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1796 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1797 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1798
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1799 private void setEntryState(BciBlock block, int dimension, FrameStateBuilder entryState) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1800 int id = block.id;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1801 if (dimension == 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1802 this.entryStateArray[id] = entryState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1803 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1804 setEntryStateMultiDimension(dimension, entryState, id);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1805 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1806 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1807
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1808 private void setEntryStateMultiDimension(int dimension, FrameStateBuilder entryState, int id) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1809 if (entryStateMatrix == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1810 entryStateMatrix = new FrameStateBuilder[4][];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1811 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1812 if (dimension - 1 < entryStateMatrix.length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1813 // We are within bounds.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1814 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1815 // We are out of bounds.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1816 entryStateMatrix = Arrays.copyOf(entryStateMatrix, Math.max(entryStateMatrix.length * 2, dimension));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1817 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1818 if (entryStateMatrix[dimension - 1] == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1819 entryStateMatrix[dimension - 1] = new FrameStateBuilder[blockMap.getBlockCount()];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1820 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1821 entryStateMatrix[dimension - 1][id] = entryState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1822 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1823
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1824 private void setFirstInstruction(BciBlock block, int dimension, FixedWithNextNode firstInstruction) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1825 int id = block.id;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1826 if (dimension == 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1827 this.firstInstructionArray[id] = firstInstruction;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1828 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1829 setFirstInstructionMultiDimension(dimension, firstInstruction, id);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1830 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1831 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1832
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1833 private void setFirstInstructionMultiDimension(int dimension, FixedWithNextNode firstInstruction, int id) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1834 if (firstInstructionMatrix == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1835 firstInstructionMatrix = new FixedWithNextNode[4][];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1836 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1837 if (dimension - 1 < firstInstructionMatrix.length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1838 // We are within bounds.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1839 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1840 // We are out of bounds.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1841 firstInstructionMatrix = Arrays.copyOf(firstInstructionMatrix, Math.max(firstInstructionMatrix.length * 2, dimension));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1842 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1843 if (firstInstructionMatrix[dimension - 1] == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1844 firstInstructionMatrix[dimension - 1] = new FixedWithNextNode[blockMap.getBlockCount()];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1845 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1846 firstInstructionMatrix[dimension - 1][id] = firstInstruction;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1847 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1848
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1849 private FixedWithNextNode getFirstInstruction(BciBlock block, int dimension) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1850 int id = block.id;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1851 if (dimension == 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1852 return firstInstructionArray[id];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1853 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1854 return getFirstInstructionMultiDimension(dimension, id);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1855 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1856 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1857
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1858 private FixedWithNextNode getFirstInstructionMultiDimension(int dimension, int id) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1859 if (firstInstructionMatrix != null && dimension - 1 < firstInstructionMatrix.length) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1860 FixedWithNextNode[] firstInstructionArrayEntry = firstInstructionMatrix[dimension - 1];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1861 if (firstInstructionArrayEntry == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1862 return null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1863 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1864 return firstInstructionArrayEntry[id];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1865 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1866 return null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1867 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1868 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1869
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1870 private FixedNode createTarget(double probability, BciBlock block, FrameStateBuilder stateAfter) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1871 assert probability >= 0 && probability <= 1.01 : probability;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1872 if (isNeverExecutedCode(probability)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1873 return graph.add(new DeoptimizeNode(InvalidateReprofile, UnreachedCode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1874 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1875 assert block != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1876 return createTarget(block, stateAfter);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1877 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1878 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1879
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1880 private FixedNode createTarget(BciBlock block, FrameStateBuilder state) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1881 return createTarget(block, state, false, false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1882 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1883
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1884 private FixedNode createTarget(BciBlock block, FrameStateBuilder state, boolean canReuseInstruction, boolean canReuseState) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1885 assert block != null && state != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1886 assert !block.isExceptionEntry \|\| state.stackSize() == 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1887
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1888 int operatingDimension = findOperatingDimension(block, state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1889
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1890 if (getFirstInstruction(block, operatingDimension) == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1891 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1892 * This is the first time we see this block as a branch target. Create and return a
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1893 * placeholder that later can be replaced with a MergeNode when we see this block again.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1894 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1895 FixedNode targetNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1896 if (canReuseInstruction && (block.getPredecessorCount() == 1 \|\| !controlFlowSplit) && !block.isLoopHeader && (currentBlock.loops & ~block.loops) == 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1897 setFirstInstruction(block, operatingDimension, lastInstr);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1898 lastInstr = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1899 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1900 setFirstInstruction(block, operatingDimension, graph.add(new BeginNode()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1901 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1902 targetNode = getFirstInstruction(block, operatingDimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1903 Target target = checkLoopExit(targetNode, block, state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1904 FixedNode result = target.fixed;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1905 FrameStateBuilder currentEntryState = target.state == state ? (canReuseState ? state : state.copy()) : target.state;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1906 setEntryState(block, operatingDimension, currentEntryState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1907 currentEntryState.clearNonLiveLocals(block, liveness, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1908
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1909 Debug.log("createTarget %s: first visit, result: %s", block, targetNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1910 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1911 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1912
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1913 // We already saw this block before, so we have to merge states.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1914 if (!getEntryState(block, operatingDimension).isCompatibleWith(state)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1915 throw bailout("stacks do not match; bytecodes would not verify");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1916 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1917
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1918 if (getFirstInstruction(block, operatingDimension) instanceof LoopBeginNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1919 assert this.explodeLoops \|\| (block.isLoopHeader && currentBlock.getId() >= block.getId()) : "must be backward branch";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1920 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1921 * Backward loop edge. We need to create a special LoopEndNode and merge with the loop
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1922 * begin node created before.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1923 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1924 LoopBeginNode loopBegin = (LoopBeginNode) getFirstInstruction(block, operatingDimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1925 LoopEndNode loopEnd = graph.add(new LoopEndNode(loopBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1926 if (parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1927 loopEnd.disableSafepoint();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1928 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1929 Target target = checkLoopExit(loopEnd, block, state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1930 FixedNode result = target.fixed;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1931 getEntryState(block, operatingDimension).merge(loopBegin, target.state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1932
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1933 Debug.log("createTarget %s: merging backward branch to loop header %s, result: %s", block, loopBegin, result);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1934 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1935 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1936 assert currentBlock == null \|\| currentBlock.getId() < block.getId() \|\| this.mergeExplosions : "must not be backward branch";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1937 assert getFirstInstruction(block, operatingDimension).next() == null \|\| this.mergeExplosions : "bytecodes already parsed for block";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1938
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1939 if (getFirstInstruction(block, operatingDimension) instanceof AbstractBeginNode && !(getFirstInstruction(block, operatingDimension) instanceof AbstractMergeNode)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1940 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1941 * This is the second time we see this block. Create the actual MergeNode and the End
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1942 * Node for the already existing edge.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1943 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1944 AbstractBeginNode beginNode = (AbstractBeginNode) getFirstInstruction(block, operatingDimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1945
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1946 // The EndNode for the already existing edge.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1947 EndNode end = graph.add(new EndNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1948 // The MergeNode that replaces the placeholder.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1949 AbstractMergeNode mergeNode = graph.add(new MergeNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1950 FixedNode next = beginNode.next();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1951
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1952 if (beginNode.predecessor() instanceof ControlSplitNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1953 beginNode.setNext(end);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1954 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1955 beginNode.replaceAtPredecessor(end);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1956 beginNode.safeDelete();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1957 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1958
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1959 mergeNode.addForwardEnd(end);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1960 mergeNode.setNext(next);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1961
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1962 setFirstInstruction(block, operatingDimension, mergeNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1963 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1964
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1965 AbstractMergeNode mergeNode = (AbstractMergeNode) getFirstInstruction(block, operatingDimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1966
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1967 // The EndNode for the newly merged edge.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1968 EndNode newEnd = graph.add(new EndNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1969 Target target = checkLoopExit(newEnd, block, state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1970 FixedNode result = target.fixed;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1971 getEntryState(block, operatingDimension).merge(mergeNode, target.state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1972 mergeNode.addForwardEnd(newEnd);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1973
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1974 Debug.log("createTarget %s: merging state, result: %s", block, result);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1975 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1976 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1977
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1978 private int findOperatingDimension(BciBlock block, FrameStateBuilder state) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1979 if (this.explodeLoops && this.explodeLoopsContext != null && !this.explodeLoopsContext.isEmpty()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1980 return findOperatingDimensionWithLoopExplosion(block, state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1981 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1982 return this.getCurrentDimension();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1983 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1984
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1985 private int findOperatingDimensionWithLoopExplosion(BciBlock block, FrameStateBuilder state) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1986 for (ExplodedLoopContext context : explodeLoopsContext) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1987 if (context.header == block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1988
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1989 if (this.mergeExplosions) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1990 state.clearNonLiveLocals(block, liveness, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1991 Integer cachedDimension = mergeExplosionsMap.get(state);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1992 if (cachedDimension != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1993 return cachedDimension;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1994 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1995 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1996
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1997 // We have a hit on our current explosion context loop begin.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1998 if (context.targetPeelIteration == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	1999 context.targetPeelIteration = new int[1];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2000 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2001 context.targetPeelIteration = Arrays.copyOf(context.targetPeelIteration, context.targetPeelIteration.length + 1);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2002 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2003
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2004 // This is the first hit => allocate a new dimension and at the same
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2005 // time mark the context loop begin as hit during the current
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2006 // iteration.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2007 if (this.mergeExplosions) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2008 this.addToMergeCache(state, nextPeelIteration);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2009 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2010 context.targetPeelIteration[context.targetPeelIteration.length - 1] = nextPeelIteration++;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2011 if (nextPeelIteration > MaximumLoopExplosionCount.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2012 String message = "too many loop explosion iterations - does the explosion not terminate for method " + method + "?";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2013 if (FailedLoopExplosionIsFatal.getValue()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2014 throw new RuntimeException(message);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2015 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2016 throw bailout(message);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2017 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2018 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2019
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2020 // Operate on the target dimension.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2021 return context.targetPeelIteration[context.targetPeelIteration.length - 1];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2022 } else if (block.getId() > context.header.getId() && block.getId() <= context.header.loopEnd) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2023 // We hit the range of this context.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2024 return context.peelIteration;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2025 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2026 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2027
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2028 // No dimension found.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2029 return 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2030 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2031
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2032 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2033 * Returns a block begin node with the specified state. If the specified probability is 0, the
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2034 * block deoptimizes immediately.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2035 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2036 private AbstractBeginNode createBlockTarget(double probability, BciBlock block, FrameStateBuilder stateAfter) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2037 FixedNode target = createTarget(probability, block, stateAfter);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2038 AbstractBeginNode begin = BeginNode.begin(target);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2039
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2040 assert !(target instanceof DeoptimizeNode && begin instanceof BeginStateSplitNode && ((BeginStateSplitNode) begin).stateAfter() != null) : "We are not allowed to set the stateAfter of the begin node, because we have to deoptimize "
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2041 + "to a bci _before_ the actual if, so that the interpreter can update the profiling information.";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2042 return begin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2043 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2044
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2045 private ValueNode synchronizedObject(FrameStateBuilder state, ResolvedJavaMethod target) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2046 if (target.isStatic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2047 return appendConstant(target.getDeclaringClass().getJavaClass());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2048 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2049 return state.loadLocal(0, Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2050 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2051 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2052
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2053 protected void processBlock(BytecodeParser parser, BciBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2054 // Ignore blocks that have no predecessors by the time their bytecodes are parsed
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2055 int currentDimension = this.getCurrentDimension();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2056 FixedWithNextNode firstInstruction = getFirstInstruction(block, currentDimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2057 if (firstInstruction == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2058 Debug.log("Ignoring block %s", block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2059 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2060 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2061 try (Indent indent = Debug.logAndIndent("Parsing block %s firstInstruction: %s loopHeader: %b", block, firstInstruction, block.isLoopHeader)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2062
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2063 lastInstr = firstInstruction;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2064 frameState = getEntryState(block, currentDimension);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2065 parser.setCurrentFrameState(frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2066 currentBlock = block;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2067
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2068 if (firstInstruction instanceof AbstractMergeNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2069 setMergeStateAfter(block, firstInstruction);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2070 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2071
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2072 if (block == blockMap.getReturnBlock()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2073 handleReturnBlock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2074 } else if (block == blockMap.getUnwindBlock()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2075 handleUnwindBlock();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2076 } else if (block instanceof ExceptionDispatchBlock) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2077 createExceptionDispatch((ExceptionDispatchBlock) block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2078 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2079 frameState.setRethrowException(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2080 iterateBytecodesForBlock(block);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2081 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2082 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2083 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2084
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2085 private void handleUnwindBlock() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2086 if (parent == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2087 frameState.setRethrowException(false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2088 createUnwind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2089 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2090 ValueNode exception = frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2091 this.unwindValue = exception;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2092 this.beforeUnwindNode = this.lastInstr;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2093 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2094 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2095
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2096 private void handleReturnBlock() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2097 Kind returnKind = method.getSignature().getReturnKind().getStackKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2098 ValueNode x = returnKind == Kind.Void ? null : frameState.pop(returnKind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2099 assert frameState.stackSize() == 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2100 beforeReturn(x, returnKind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2101 this.returnValue = x;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2102 this.beforeReturnNode = this.lastInstr;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2103 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2104
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2105 private void setMergeStateAfter(BciBlock block, FixedWithNextNode firstInstruction) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2106 AbstractMergeNode abstractMergeNode = (AbstractMergeNode) firstInstruction;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2107 if (abstractMergeNode.stateAfter() == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2108 int bci = block.startBci;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2109 if (block instanceof ExceptionDispatchBlock) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2110 bci = ((ExceptionDispatchBlock) block).deoptBci;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2111 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2112 abstractMergeNode.setStateAfter(createFrameState(bci, abstractMergeNode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2113 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2114 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2115
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2116 private void createUnwind() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2117 assert frameState.stackSize() == 1 : frameState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2118 ValueNode exception = frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2119 synchronizedEpilogue(BytecodeFrame.AFTER_EXCEPTION_BCI, null, null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2120 append(new UnwindNode(exception));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2121 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2122
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2123 private void synchronizedEpilogue(int bci, ValueNode currentReturnValue, Kind currentReturnValueKind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2124 if (method.isSynchronized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2125 if (currentReturnValue != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2126 frameState.push(currentReturnValueKind, currentReturnValue);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2127 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2128 genMonitorExit(methodSynchronizedObject, currentReturnValue, bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2129 assert !frameState.rethrowException();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2130 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2131 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2132
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2133 private void createExceptionDispatch(ExceptionDispatchBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2134 assert frameState.stackSize() == 1 : frameState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2135 if (block.handler.isCatchAll()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2136 assert block.getSuccessorCount() == 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2137 appendGoto(block.getSuccessor(0));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2138 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2139 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2140
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2141 JavaType catchType = block.handler.getCatchType();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2142 if (graphBuilderConfig.eagerResolving()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2143 catchType = lookupType(block.handler.catchTypeCPI(), INSTANCEOF);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2144 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2145 boolean initialized = (catchType instanceof ResolvedJavaType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2146 if (initialized && graphBuilderConfig.getSkippedExceptionTypes() != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2147 ResolvedJavaType resolvedCatchType = (ResolvedJavaType) catchType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2148 for (ResolvedJavaType skippedType : graphBuilderConfig.getSkippedExceptionTypes()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2149 if (skippedType.isAssignableFrom(resolvedCatchType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2150 BciBlock nextBlock = block.getSuccessorCount() == 1 ? blockMap.getUnwindBlock() : block.getSuccessor(1);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2151 ValueNode exception = frameState.stack[0];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2152 FixedNode trueSuccessor = graph.add(new DeoptimizeNode(InvalidateReprofile, UnreachedCode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2153 FixedNode nextDispatch = createTarget(nextBlock, frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2154 append(new IfNode(graph.unique(new InstanceOfNode((ResolvedJavaType) catchType, exception, null)), trueSuccessor, nextDispatch, 0));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2155 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2156 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2157 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2158 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2159
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2160 if (initialized) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2161 BciBlock nextBlock = block.getSuccessorCount() == 1 ? blockMap.getUnwindBlock() : block.getSuccessor(1);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2162 ValueNode exception = frameState.stack[0];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2163 CheckCastNode checkCast = graph.add(new CheckCastNode((ResolvedJavaType) catchType, exception, null, false));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2164 frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2165 frameState.push(Kind.Object, checkCast);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2166 FixedNode catchSuccessor = createTarget(block.getSuccessor(0), frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2167 frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2168 frameState.push(Kind.Object, exception);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2169 FixedNode nextDispatch = createTarget(nextBlock, frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2170 checkCast.setNext(catchSuccessor);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2171 append(new IfNode(graph.unique(new InstanceOfNode((ResolvedJavaType) catchType, exception, null)), checkCast, nextDispatch, 0.5));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2172 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2173 handleUnresolvedExceptionType(catchType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2174 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2175 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2176
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2177 private void appendGoto(BciBlock successor) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2178 FixedNode targetInstr = createTarget(successor, frameState, true, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2179 if (lastInstr != null && lastInstr != targetInstr) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2180 lastInstr.setNext(targetInstr);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2181 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2182 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2183
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2184 protected void iterateBytecodesForBlock(BciBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2185 if (block.isLoopHeader && !explodeLoops) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2186 // Create the loop header block, which later will merge the backward branches of
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2187 // the loop.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2188 controlFlowSplit = true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2189 LoopBeginNode loopBegin = appendLoopBegin(this.lastInstr);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2190 lastInstr = loopBegin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2191
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2192 // Create phi functions for all local variables and operand stack slots.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2193 frameState.insertLoopPhis(liveness, block.loopId, loopBegin, forceLoopPhis());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2194 loopBegin.setStateAfter(createFrameState(block.startBci, loopBegin));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2195
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2196 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2197 * We have seen all forward branches. All subsequent backward branches will merge to the
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2198 * loop header. This ensures that the loop header has exactly one non-loop predecessor.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2199 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2200 setFirstInstruction(block, this.getCurrentDimension(), loopBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2201 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2202 * We need to preserve the frame state builder of the loop header so that we can merge
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2203 * values for phi functions, so make a copy of it.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2204 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2205 setEntryState(block, this.getCurrentDimension(), frameState.copy());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2206
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2207 Debug.log(" created loop header %s", loopBegin);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2208 } else if (block.isLoopHeader && explodeLoops && this.mergeExplosions) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2209 frameState = frameState.copy();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2210 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2211 assert lastInstr.next() == null : "instructions already appended at block " + block;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2212 Debug.log(" frameState: %s", frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2213
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2214 lastInstr = finishInstruction(lastInstr, frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2215
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2216 int endBCI = stream.endBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2217
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2218 stream.setBCI(block.startBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2219 int bci = block.startBci;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2220 BytecodesParsed.add(block.endBci - bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2221
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2222 /* Reset line number for new block */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2223 if (graphBuilderConfig.insertSimpleDebugInfo()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2224 previousLineNumber = -1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2225 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2226
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2227 while (bci < endBCI) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2228 if (graphBuilderConfig.insertNonSafepointDebugInfo() && !parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2229 currentLineNumber = lnt != null ? lnt.getLineNumber(bci) : (graphBuilderConfig.insertFullDebugInfo() ? -1 : bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2230 if (currentLineNumber != previousLineNumber) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2231 append(createInfoPointNode(InfopointReason.LINE_NUMBER));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2232 previousLineNumber = currentLineNumber;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2233 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2234 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2235
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2236 // read the opcode
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2237 int opcode = stream.currentBC();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2238 assert traceState();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2239 assert traceInstruction(bci, opcode, bci == block.startBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2240 if (parent == null && bci == entryBCI) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2241 if (block.getJsrScope() != JsrScope.EMPTY_SCOPE) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2242 throw new BailoutException("OSR into a JSR scope is not supported");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2243 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2244 EntryMarkerNode x = append(new EntryMarkerNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2245 frameState.insertProxies(x);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2246 x.setStateAfter(createFrameState(bci, x));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2247 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2248
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2249 try {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2250 processBytecode(bci, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2251 } catch (Throwable e) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2252 throw asParserError(e);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2253 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2254
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2255 if (lastInstr == null \|\| lastInstr.next() != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2256 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2257 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2258
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2259 stream.next();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2260 bci = stream.currentBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2261
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2262 assert block == currentBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2263 assert checkLastInstruction();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2264 lastInstr = finishInstruction(lastInstr, frameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2265 if (bci < endBCI) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2266 if (bci > block.endBci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2267 assert !block.getSuccessor(0).isExceptionEntry;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2268 assert block.numNormalSuccessors() == 1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2269 // we fell through to the next block, add a goto and break
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2270 appendGoto(block.getSuccessor(0));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2271 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2272 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2273 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2274 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2275 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2276
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2277 /* Also a hook for subclasses. */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2278 protected boolean forceLoopPhis() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2279 return graph.isOSR();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2280 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2281
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2282 protected boolean checkLastInstruction() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2283 if (lastInstr instanceof BeginNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2284 // ignore
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2285 } else if (lastInstr instanceof StateSplit) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2286 StateSplit stateSplit = (StateSplit) lastInstr;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2287 if (stateSplit.hasSideEffect()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2288 assert stateSplit.stateAfter() != null : "side effect " + lastInstr + " requires a non-null stateAfter";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2289 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2290 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2291 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2292 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2293
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2294 private LoopBeginNode appendLoopBegin(FixedWithNextNode fixedWithNext) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2295 EndNode preLoopEnd = graph.add(new EndNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2296 LoopBeginNode loopBegin = graph.add(new LoopBeginNode());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2297 fixedWithNext.setNext(preLoopEnd);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2298 // Add the single non-loop predecessor of the loop header.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2299 loopBegin.addForwardEnd(preLoopEnd);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2300 return loopBegin;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2301 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2302
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2303 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2304 * A hook for derived classes to modify the last instruction or add other instructions.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2305 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2306 * @param instr The last instruction (= fixed node) which was added.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2307 * @param state The current frame state.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2308 * @return Returns the (new) last instruction.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2309 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2310 protected FixedWithNextNode finishInstruction(FixedWithNextNode instr, FrameStateBuilder state) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2311 return instr;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2312 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2313
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2314 private InfopointNode createInfoPointNode(InfopointReason reason) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2315 if (graphBuilderConfig.insertFullDebugInfo()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2316 return new FullInfopointNode(reason, createFrameState(bci(), null));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2317 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2318 BytecodePosition position = createBytecodePosition();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2319 // Update the previous infopoint position if no new fixed nodes were inserted
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2320 if (lastInstr instanceof SimpleInfopointNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2321 SimpleInfopointNode lastInfopoint = (SimpleInfopointNode) lastInstr;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2322 if (lastInfopoint.getReason() == reason) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2323 lastInfopoint.setPosition(position);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2324 return lastInfopoint;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2325 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2326 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2327 return new SimpleInfopointNode(reason, position);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2328 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2329 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2330
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2331 private boolean traceState() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2332 if (Debug.isEnabled() && Options.TraceBytecodeParserLevel.getValue() >= TRACELEVEL_STATE && Debug.isLogEnabled()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2333 frameState.traceState();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2334 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2335 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2336 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2337
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2338 protected void genIf(ValueNode x, Condition cond, ValueNode y) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2339 assert x.getKind().getStackKind() == y.getKind().getStackKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2340 assert currentBlock.getSuccessorCount() == 2;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2341 BciBlock trueBlock = currentBlock.getSuccessor(0);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2342 BciBlock falseBlock = currentBlock.getSuccessor(1);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2343 if (trueBlock == falseBlock) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2344 // The target block is the same independent of the condition.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2345 appendGoto(trueBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2346 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2347 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2348
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2349 ValueNode a = x;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2350 ValueNode b = y;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2351
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2352 // Check whether the condition needs to mirror the operands.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2353 if (cond.canonicalMirror()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2354 a = y;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2355 b = x;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2356 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2357
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2358 // Create the logic node for the condition.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2359 LogicNode condition = createLogicNode(cond, a, b);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2360
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2361 // Check whether the condition needs to negate the result.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2362 boolean negate = cond.canonicalNegate();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2363
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2364 // Remove a logic negation node and fold it into the negate boolean.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2365 if (condition instanceof LogicNegationNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2366 LogicNegationNode logicNegationNode = (LogicNegationNode) condition;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2367 negate = !negate;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2368 condition = logicNegationNode.getValue();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2369 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2370
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2371 if (condition instanceof LogicConstantNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2372 genConstantTargetIf(trueBlock, falseBlock, negate, condition);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2373 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2374 if (condition.graph() == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2375 condition = graph.unique(condition);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2376 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2377
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2378 // Need to get probability based on current bci.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2379 double probability = branchProbability();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2380
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2381 if (negate) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2382 BciBlock tmpBlock = trueBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2383 trueBlock = falseBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2384 falseBlock = tmpBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2385 probability = 1 - probability;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2386 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2387
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2388 if (isNeverExecutedCode(probability)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2389 append(new FixedGuardNode(condition, UnreachedCode, InvalidateReprofile, true));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2390 appendGoto(falseBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2391 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2392 } else if (isNeverExecutedCode(1 - probability)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2393 append(new FixedGuardNode(condition, UnreachedCode, InvalidateReprofile, false));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2394 appendGoto(trueBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2395 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2396 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2397
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2398 int oldBci = stream.currentBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2399 int trueBlockInt = checkPositiveIntConstantPushed(trueBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2400 if (trueBlockInt != -1) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2401 int falseBlockInt = checkPositiveIntConstantPushed(falseBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2402 if (falseBlockInt != -1) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2403 if (tryGenConditionalForIf(trueBlock, falseBlock, condition, oldBci, trueBlockInt, falseBlockInt)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2404 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2405 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2406 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2407 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2408
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2409 this.controlFlowSplit = true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2410 FixedNode trueSuccessor = createTarget(trueBlock, frameState, false, false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2411 FixedNode falseSuccessor = createTarget(falseBlock, frameState, false, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2412 ValueNode ifNode = genIfNode(condition, trueSuccessor, falseSuccessor, probability);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2413 append(ifNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2414 if (parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2415 if (x instanceof BranchProbabilityNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2416 ((BranchProbabilityNode) x).simplify(null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2417 } else if (y instanceof BranchProbabilityNode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2418 ((BranchProbabilityNode) y).simplify(null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2419 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2420 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2421 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2422 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2423
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2424 private boolean tryGenConditionalForIf(BciBlock trueBlock, BciBlock falseBlock, LogicNode condition, int oldBci, int trueBlockInt, int falseBlockInt) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2425 if (gotoOrFallThroughAfterConstant(trueBlock) && gotoOrFallThroughAfterConstant(falseBlock) && trueBlock.getSuccessor(0) == falseBlock.getSuccessor(0)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2426 genConditionalForIf(trueBlock, condition, oldBci, trueBlockInt, falseBlockInt, false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2427 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2428 } else if (this.parent != null && returnAfterConstant(trueBlock) && returnAfterConstant(falseBlock)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2429 genConditionalForIf(trueBlock, condition, oldBci, trueBlockInt, falseBlockInt, true);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2430 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2431 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2432 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2433 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2434
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2435 private void genConditionalForIf(BciBlock trueBlock, LogicNode condition, int oldBci, int trueBlockInt, int falseBlockInt, boolean genReturn) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2436 ConstantNode trueValue = graph.unique(ConstantNode.forInt(trueBlockInt));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2437 ConstantNode falseValue = graph.unique(ConstantNode.forInt(falseBlockInt));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2438 ValueNode conditionalNode = ConditionalNode.create(condition, trueValue, falseValue);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2439 if (conditionalNode.graph() == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2440 conditionalNode = graph.addOrUnique(conditionalNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2441 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2442 if (genReturn) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2443 Kind returnKind = method.getSignature().getReturnKind().getStackKind();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2444 this.genReturn(conditionalNode, returnKind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2445 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2446 frameState.push(Kind.Int, conditionalNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2447 appendGoto(trueBlock.getSuccessor(0));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2448 stream.setBCI(oldBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2449 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2450 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2451
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2452 private LogicNode createLogicNode(Condition cond, ValueNode a, ValueNode b) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2453 LogicNode condition;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2454 assert !a.getKind().isNumericFloat();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2455 if (cond == Condition.EQ \|\| cond == Condition.NE) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2456 if (a.getKind() == Kind.Object) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2457 condition = genObjectEquals(a, b);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2458 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2459 condition = genIntegerEquals(a, b);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2460 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2461 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2462 assert a.getKind() != Kind.Object && !cond.isUnsigned();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2463 condition = genIntegerLessThan(a, b);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2464 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2465 return condition;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2466 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2467
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2468 private void genConstantTargetIf(BciBlock trueBlock, BciBlock falseBlock, boolean negate, LogicNode condition) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2469 LogicConstantNode constantLogicNode = (LogicConstantNode) condition;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2470 boolean value = constantLogicNode.getValue();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2471 if (negate) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2472 value = !value;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2473 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2474 BciBlock nextBlock = falseBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2475 if (value) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2476 nextBlock = trueBlock;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2477 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2478 appendGoto(nextBlock);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2479 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2480
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2481 private int checkPositiveIntConstantPushed(BciBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2482 stream.setBCI(block.startBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2483 int currentBC = stream.currentBC();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2484 if (currentBC >= Bytecodes.ICONST_0 && currentBC <= Bytecodes.ICONST_5) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2485 int constValue = currentBC - Bytecodes.ICONST_0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2486 return constValue;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2487 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2488 return -1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2489 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2490
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2491 private boolean gotoOrFallThroughAfterConstant(BciBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2492 stream.setBCI(block.startBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2493 int currentBCI = stream.nextBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2494 stream.setBCI(currentBCI);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2495 int currentBC = stream.currentBC();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2496 return stream.currentBCI() > block.endBci \|\| currentBC == Bytecodes.GOTO \|\| currentBC == Bytecodes.GOTO_W;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2497 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2498
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2499 private boolean returnAfterConstant(BciBlock block) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2500 stream.setBCI(block.startBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2501 int currentBCI = stream.nextBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2502 stream.setBCI(currentBCI);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2503 int currentBC = stream.currentBC();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2504 return currentBC == Bytecodes.IRETURN;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2505 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2506
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2507 public StampProvider getStampProvider() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2508 return stampProvider;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2509 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2510
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2511 public MetaAccessProvider getMetaAccess() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2512 return metaAccess;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2513 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2514
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2515 public void push(Kind slotKind, ValueNode value) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2516 assert value.isAlive();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2517 frameState.push(slotKind, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2518 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2519
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2520 private int getCurrentDimension() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2521 if (this.explodeLoopsContext == null \|\| this.explodeLoopsContext.isEmpty()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2522 return 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2523 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2524 return this.explodeLoopsContext.peek().peelIteration;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2525 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2526 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2527
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2528 public ConstantReflectionProvider getConstantReflection() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2529 return constantReflection;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2530 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2531
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2532 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2533 * Gets the graph being processed by this builder.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2534 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2535 public StructuredGraph getGraph() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2536 return graph;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2537 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2538
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2539 public BytecodeParser getParent() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2540 return parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2541 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2542
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2543 public IntrinsicContext getIntrinsic() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2544 return intrinsicContext;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2545 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2546
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2547 @Override
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2548 public String toString() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2549 Formatter fmt = new Formatter();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2550 BytecodeParser bp = this;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2551 String indent = "";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2552 while (bp != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2553 if (bp != this) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2554 fmt.format("%n%s", indent);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2555 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2556 fmt.format("%s [bci: %d, intrinsic: %s]", bp.method.asStackTraceElement(bp.bci()), bp.bci(), bp.parsingIntrinsic());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2557 fmt.format("%n%s", new BytecodeDisassembler().disassemble(bp.method, bp.bci(), bp.bci() + 10));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2558 bp = bp.parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2559 indent += " ";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2560 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2561 return fmt.toString();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2562 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2563
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2564 public BailoutException bailout(String string) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2565 FrameState currentFrameState = createFrameState(bci(), null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2566 StackTraceElement[] elements = GraphUtil.approxSourceStackTraceElement(currentFrameState);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2567 BailoutException bailout = new BailoutException(string);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2568 throw GraphUtil.createBailoutException(string, bailout, elements);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2569 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2570
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2571 private FrameState createFrameState(int bci, StateSplit forStateSplit) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2572 if (currentBlock != null && bci > currentBlock.endBci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2573 frameState.clearNonLiveLocals(currentBlock, liveness, false);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2574 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2575 return frameState.create(bci, forStateSplit);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2576 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2577
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2578 public void setStateAfter(StateSplit sideEffect) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2579 assert sideEffect.hasSideEffect();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2580 FrameState stateAfter = createFrameState(stream.nextBCI(), sideEffect);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2581 sideEffect.setStateAfter(stateAfter);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2582 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2583
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2584 private BytecodePosition createBytecodePosition() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2585 return frameState.createBytecodePosition(bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2586 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2587
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2588 public void setCurrentFrameState(FrameStateBuilder frameState) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2589 this.frameState = frameState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2590 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2591
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2592 protected final BytecodeStream getStream() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2593 return stream;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2594 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2595
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2596 public int bci() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2597 return stream.currentBCI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2598 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2599
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2600 public void loadLocal(int index, Kind kind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2601 ValueNode value = frameState.loadLocal(index, kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2602 frameState.push(kind, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2603 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2604
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2605 public void storeLocal(Kind kind, int index) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2606 ValueNode value = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2607 frameState.storeLocal(index, kind, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2608 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2609
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2610 private void genLoadConstant(int cpi, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2611 Object con = lookupConstant(cpi, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2612
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2613 if (con instanceof JavaType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2614 // this is a load of class constant which might be unresolved
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2615 JavaType type = (JavaType) con;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2616 if (type instanceof ResolvedJavaType) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2617 frameState.push(Kind.Object, appendConstant(((ResolvedJavaType) type).getJavaClass()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2618 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2619 handleUnresolvedLoadConstant(type);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2620 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2621 } else if (con instanceof JavaConstant) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2622 JavaConstant constant = (JavaConstant) con;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2623 frameState.push(constant.getKind(), appendConstant(constant));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2624 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2625 throw new Error("lookupConstant returned an object of incorrect type");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2626 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2627 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2628
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2629 private void genLoadIndexed(Kind kind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2630 ValueNode index = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2631 ValueNode array = emitExplicitExceptions(frameState.pop(Kind.Object), index);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2632
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2633 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2634 if (plugin.handleLoadIndexed(this, array, index, kind)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2635 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2636 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2637 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2638
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2639 frameState.push(kind, append(genLoadIndexed(array, index, kind)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2640 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2641
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2642 private void genStoreIndexed(Kind kind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2643 ValueNode value = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2644 ValueNode index = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2645 ValueNode array = emitExplicitExceptions(frameState.pop(Kind.Object), index);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2646
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2647 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2648 if (plugin.handleStoreIndexed(this, array, index, kind, value)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2649 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2650 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2651 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2652
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2653 genStoreIndexed(array, index, kind, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2654 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2655
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2656 private void genArithmeticOp(Kind kind, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2657 ValueNode y = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2658 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2659 ValueNode v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2660 switch (opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2661 case IADD:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2662 case LADD:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2663 v = genIntegerAdd(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2664 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2665 case FADD:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2666 case DADD:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2667 v = genFloatAdd(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2668 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2669 case ISUB:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2670 case LSUB:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2671 v = genIntegerSub(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2672 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2673 case FSUB:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2674 case DSUB:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2675 v = genFloatSub(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2676 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2677 case IMUL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2678 case LMUL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2679 v = genIntegerMul(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2680 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2681 case FMUL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2682 case DMUL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2683 v = genFloatMul(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2684 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2685 case FDIV:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2686 case DDIV:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2687 v = genFloatDiv(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2688 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2689 case FREM:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2690 case DREM:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2691 v = genFloatRem(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2692 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2693 default:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2694 throw shouldNotReachHere();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2695 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2696 frameState.push(kind, append(v));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2697 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2698
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2699 private void genIntegerDivOp(Kind kind, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2700 ValueNode y = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2701 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2702 ValueNode v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2703 switch (opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2704 case IDIV:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2705 case LDIV:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2706 v = genIntegerDiv(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2707 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2708 case IREM:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2709 case LREM:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2710 v = genIntegerRem(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2711 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2712 default:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2713 throw shouldNotReachHere();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2714 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2715 frameState.push(kind, append(v));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2716 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2717
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2718 private void genNegateOp(Kind kind) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2719 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2720 frameState.push(kind, append(genNegateOp(x)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2721 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2722
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2723 private void genShiftOp(Kind kind, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2724 ValueNode s = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2725 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2726 ValueNode v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2727 switch (opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2728 case ISHL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2729 case LSHL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2730 v = genLeftShift(x, s);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2731 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2732 case ISHR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2733 case LSHR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2734 v = genRightShift(x, s);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2735 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2736 case IUSHR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2737 case LUSHR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2738 v = genUnsignedRightShift(x, s);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2739 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2740 default:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2741 throw shouldNotReachHere();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2742 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2743 frameState.push(kind, append(v));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2744 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2745
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2746 private void genLogicOp(Kind kind, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2747 ValueNode y = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2748 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2749 ValueNode v;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2750 switch (opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2751 case IAND:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2752 case LAND:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2753 v = genAnd(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2754 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2755 case IOR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2756 case LOR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2757 v = genOr(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2758 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2759 case IXOR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2760 case LXOR:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2761 v = genXor(x, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2762 break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2763 default:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2764 throw shouldNotReachHere();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2765 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2766 frameState.push(kind, append(v));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2767 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2768
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2769 private void genCompareOp(Kind kind, boolean isUnorderedLess) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2770 ValueNode y = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2771 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2772 frameState.push(Kind.Int, append(genNormalizeCompare(x, y, isUnorderedLess)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2773 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2774
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2775 private void genFloatConvert(FloatConvert op, Kind from, Kind to) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2776 ValueNode input = frameState.pop(from);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2777 frameState.push(to, append(genFloatConvert(op, input)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2778 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2779
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2780 private void genSignExtend(Kind from, Kind to) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2781 ValueNode input = frameState.pop(from);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2782 if (from != from.getStackKind()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2783 input = append(genNarrow(input, from.getBitCount()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2784 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2785 frameState.push(to, append(genSignExtend(input, to.getBitCount())));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2786 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2787
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2788 private void genZeroExtend(Kind from, Kind to) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2789 ValueNode input = frameState.pop(from);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2790 if (from != from.getStackKind()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2791 input = append(genNarrow(input, from.getBitCount()));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2792 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2793 frameState.push(to, append(genZeroExtend(input, to.getBitCount())));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2794 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2795
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2796 private void genNarrow(Kind from, Kind to) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2797 ValueNode input = frameState.pop(from);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2798 frameState.push(to, append(genNarrow(input, to.getBitCount())));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2799 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2800
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2801 private void genIncrement() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2802 int index = getStream().readLocalIndex();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2803 int delta = getStream().readIncrement();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2804 ValueNode x = frameState.loadLocal(index, Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2805 ValueNode y = appendConstant(JavaConstant.forInt(delta));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2806 frameState.storeLocal(index, Kind.Int, append(genIntegerAdd(x, y)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2807 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2808
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2809 private void genIfZero(Condition cond) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2810 ValueNode y = appendConstant(JavaConstant.INT_0);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2811 ValueNode x = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2812 genIf(x, cond, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2813 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2814
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2815 private void genIfNull(Condition cond) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2816 ValueNode y = appendConstant(JavaConstant.NULL_POINTER);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2817 ValueNode x = frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2818 genIf(x, cond, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2819 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2820
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2821 private void genIfSame(Kind kind, Condition cond) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2822 ValueNode y = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2823 ValueNode x = frameState.pop(kind);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2824 genIf(x, cond, y);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2825 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2826
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2827 protected JavaType lookupType(int cpi, int bytecode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2828 maybeEagerlyResolve(cpi, bytecode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2829 JavaType result = constantPool.lookupType(cpi, bytecode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2830 assert !graphBuilderConfig.unresolvedIsError() \|\| result instanceof ResolvedJavaType;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2831 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2832 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2833
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2834 private JavaMethod lookupMethod(int cpi, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2835 maybeEagerlyResolve(cpi, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2836 JavaMethod result = constantPool.lookupMethod(cpi, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2837 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2838 * In general, one cannot assume that the declaring class being initialized is useful, since
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2839 * the actual concrete receiver may be a different class (except for static calls). Also,
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2840 * interfaces are initialized only under special circumstances, so that this assertion would
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2841 * often fail for interface calls.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2842 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2843 assert !graphBuilderConfig.unresolvedIsError() \|\| (result instanceof ResolvedJavaMethod && (opcode != INVOKESTATIC \|\| ((ResolvedJavaMethod) result).getDeclaringClass().isInitialized())) : result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2844 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2845 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2846
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2847 private JavaField lookupField(int cpi, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2848 maybeEagerlyResolve(cpi, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2849 JavaField result = constantPool.lookupField(cpi, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2850 assert !graphBuilderConfig.unresolvedIsError() \|\| (result instanceof ResolvedJavaField && ((ResolvedJavaField) result).getDeclaringClass().isInitialized()) : result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2851 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2852 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2853
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2854 private Object lookupConstant(int cpi, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2855 maybeEagerlyResolve(cpi, opcode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2856 Object result = constantPool.lookupConstant(cpi);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2857 assert !graphBuilderConfig.eagerResolving() \|\| !(result instanceof JavaType) \|\| (result instanceof ResolvedJavaType) : result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2858 return result;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2859 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2860
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2861 private void maybeEagerlyResolve(int cpi, int bytecode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2862 if (graphBuilderConfig.eagerResolving() \|\| intrinsicContext != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2863 constantPool.loadReferencedType(cpi, bytecode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2864 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2865 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2866
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2867 private JavaTypeProfile getProfileForTypeCheck(ResolvedJavaType type) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2868 if (parsingIntrinsic() \|\| profilingInfo == null \|\| !optimisticOpts.useTypeCheckHints() \|\| !canHaveSubtype(type)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2869 return null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2870 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2871 return profilingInfo.getTypeProfile(bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2872 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2873 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2874
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2875 private void genCheckCast() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2876 int cpi = getStream().readCPI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2877 JavaType type = lookupType(cpi, CHECKCAST);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2878 ValueNode object = frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2879
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2880 if (!(type instanceof ResolvedJavaType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2881 handleUnresolvedCheckCast(type, object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2882 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2883 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2884 ResolvedJavaType resolvedType = (ResolvedJavaType) type;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2885 JavaTypeProfile profile = getProfileForTypeCheck(resolvedType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2886
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2887 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2888 if (plugin.handleCheckCast(this, object, resolvedType, profile)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2889 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2890 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2891 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2892
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2893 ValueNode checkCastNode = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2894 if (profile != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2895 if (profile.getNullSeen().isFalse()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2896 object = append(GuardingPiNode.createNullCheck(object));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2897 ResolvedJavaType singleType = profile.asSingleType();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2898 if (singleType != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2899 LogicNode typeCheck = append(TypeCheckNode.create(singleType, object));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2900 if (typeCheck.isTautology()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2901 checkCastNode = object;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2902 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2903 GuardingPiNode piNode = append(new GuardingPiNode(object, typeCheck, false, DeoptimizationReason.TypeCheckedInliningViolated, DeoptimizationAction.InvalidateReprofile,
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2904 StampFactory.exactNonNull(singleType)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2905 checkCastNode = piNode;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2906 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2907 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2908 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2909 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2910 if (checkCastNode == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2911 checkCastNode = append(createCheckCast(resolvedType, object, profile, false));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2912 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2913 frameState.push(Kind.Object, checkCastNode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2914 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2915
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2916 private void genInstanceOf() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2917 int cpi = getStream().readCPI();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2918 JavaType type = lookupType(cpi, INSTANCEOF);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2919 ValueNode object = frameState.pop(Kind.Object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2920
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2921 if (!(type instanceof ResolvedJavaType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2922 handleUnresolvedInstanceOf(type, object);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2923 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2924 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2925 ResolvedJavaType resolvedType = (ResolvedJavaType) type;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2926 JavaTypeProfile profile = getProfileForTypeCheck(resolvedType);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2927
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2928 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2929 if (plugin.handleInstanceOf(this, object, resolvedType, profile)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2930 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2931 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2932 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2933
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2934 ValueNode instanceOfNode = null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2935 if (profile != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2936 if (profile.getNullSeen().isFalse()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2937 object = append(GuardingPiNode.createNullCheck(object));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2938 ResolvedJavaType singleType = profile.asSingleType();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2939 if (singleType != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2940 LogicNode typeCheck = append(TypeCheckNode.create(singleType, object));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2941 append(new FixedGuardNode(typeCheck, DeoptimizationReason.TypeCheckedInliningViolated, DeoptimizationAction.InvalidateReprofile));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2942 instanceOfNode = LogicConstantNode.forBoolean(resolvedType.isAssignableFrom(singleType));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2943 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2944 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2945 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2946 if (instanceOfNode == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2947 instanceOfNode = createInstanceOf(resolvedType, object, profile);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2948 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2949 frameState.push(Kind.Int, append(genConditional(genUnique(instanceOfNode))));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2950 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2951
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2952 void genNewInstance(int cpi) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2953 JavaType type = lookupType(cpi, NEW);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2954
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2955 if (!(type instanceof ResolvedJavaType) \|\| !((ResolvedJavaType) type).isInitialized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2956 handleUnresolvedNewInstance(type);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2957 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2958 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2959 ResolvedJavaType resolvedType = (ResolvedJavaType) type;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2960
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2961 ResolvedJavaType[] skippedExceptionTypes = this.graphBuilderConfig.getSkippedExceptionTypes();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2962 if (skippedExceptionTypes != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2963 for (ResolvedJavaType exceptionType : skippedExceptionTypes) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2964 if (exceptionType.isAssignableFrom(resolvedType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2965 append(new DeoptimizeNode(DeoptimizationAction.None, TransferToInterpreter));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2966 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2967 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2968 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2969 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2970
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2971 frameState.push(Kind.Object, append(createNewInstance(resolvedType, true)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2972 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2973
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2974 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2975 * Gets the kind of array elements for the array type code that appears in a
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2976 * {@link Bytecodes#NEWARRAY} bytecode.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2977 *
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2978 * @param code the array type code
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2979 * @return the kind from the array type code
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2980 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2981 private static Class<?> arrayTypeCodeToClass(int code) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2982 switch (code) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2983 case 4:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2984 return boolean.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2985 case 5:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2986 return char.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2987 case 6:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2988 return float.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2989 case 7:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2990 return double.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2991 case 8:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2992 return byte.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2993 case 9:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2994 return short.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2995 case 10:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2996 return int.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2997 case 11:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2998 return long.class;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	2999 default:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3000 throw new IllegalArgumentException("unknown array type code: " + code);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3001 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3002 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3003
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3004 private void genNewPrimitiveArray(int typeCode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3005 ResolvedJavaType elementType = metaAccess.lookupJavaType(arrayTypeCodeToClass(typeCode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3006 ValueNode length = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3007 frameState.push(Kind.Object, append(createNewArray(elementType, length, true)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3008 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3009
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3010 private void genNewObjectArray(int cpi) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3011 JavaType type = lookupType(cpi, ANEWARRAY);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3012 ValueNode length = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3013
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3014 if (!(type instanceof ResolvedJavaType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3015 handleUnresolvedNewObjectArray(type, length);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3016 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3017 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3018 ResolvedJavaType resolvedType = (ResolvedJavaType) type;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3019
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3020 frameState.push(Kind.Object, append(createNewArray(resolvedType, length, true)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3021 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3022
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3023 private void genNewMultiArray(int cpi) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3024 JavaType type = lookupType(cpi, MULTIANEWARRAY);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3025 int rank = getStream().readUByte(bci() + 3);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3026 List<ValueNode> dims = new ArrayList<>(Collections.nCopies(rank, null));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3027 for (int i = rank - 1; i >= 0; i--) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3028 dims.set(i, frameState.pop(Kind.Int));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3029 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3030
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3031 if (!(type instanceof ResolvedJavaType)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3032 handleUnresolvedNewMultiArray(type, dims);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3033 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3034 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3035 ResolvedJavaType resolvedType = (ResolvedJavaType) type;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3036
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3037 frameState.push(Kind.Object, append(createNewMultiArray(resolvedType, dims)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3038 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3039
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3040 private void genGetField(JavaField field) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3041 ValueNode receiver = emitExplicitExceptions(frameState.pop(Kind.Object), null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3042
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3043 if (!(field instanceof ResolvedJavaField) \|\| !((ResolvedJavaField) field).getDeclaringClass().isInitialized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3044 handleUnresolvedLoadField(field, receiver);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3045 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3046 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3047 ResolvedJavaField resolvedField = (ResolvedJavaField) field;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3048
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3049 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3050 if (plugin.handleLoadField(this, receiver, resolvedField)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3051 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3052 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3053 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3054
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3055 frameState.push(field.getKind(), append(genLoadField(receiver, resolvedField)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3056 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3057
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3058 /**
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3059 * @param receiver the receiver of an object based operation
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3060 * @param index the index of an array based operation that is to be tested for out of bounds.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3061 * This is null for a non-array operation.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3062 * @return the receiver value possibly modified to have a tighter stamp
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3063 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3064 protected ValueNode emitExplicitExceptions(ValueNode receiver, ValueNode index) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3065 assert receiver != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3066 if (graphBuilderConfig.omitAllExceptionEdges() \|\| profilingInfo == null \|\|
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3067 (optimisticOpts.useExceptionProbabilityForOperations() && profilingInfo.getExceptionSeen(bci()) == TriState.FALSE && !GraalOptions.StressExplicitExceptionCode.getValue())) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3068 return receiver;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3069 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3070
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3071 ValueNode nonNullReceiver = emitExplicitNullCheck(receiver);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3072 if (index != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3073 ValueNode length = append(genArrayLength(nonNullReceiver));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3074 emitExplicitBoundsCheck(index, length);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3075 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3076 EXPLICIT_EXCEPTIONS.increment();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3077 return nonNullReceiver;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3078 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3079
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3080 private void genPutField(JavaField field) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3081 ValueNode value = frameState.pop(field.getKind());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3082 ValueNode receiver = emitExplicitExceptions(frameState.pop(Kind.Object), null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3083
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3084 if (!(field instanceof ResolvedJavaField) \|\| !((ResolvedJavaField) field).getDeclaringClass().isInitialized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3085 handleUnresolvedStoreField(field, value, receiver);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3086 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3087 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3088 ResolvedJavaField resolvedField = (ResolvedJavaField) field;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3089
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3090 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3091 if (plugin.handleStoreField(this, receiver, resolvedField, value)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3092 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3093 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3094 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3095
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3096 genStoreField(receiver, resolvedField, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3097 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3098
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3099 private void genGetStatic(JavaField field) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3100 if (!(field instanceof ResolvedJavaField) \|\| !((ResolvedJavaType) field.getDeclaringClass()).isInitialized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3101 handleUnresolvedLoadField(field, null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3102 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3103 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3104 ResolvedJavaField resolvedField = (ResolvedJavaField) field;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3105
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3106 /*
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3107 * Javac does not allow use of "$assertionsDisabled" for a field name but Eclipse does, in
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3108 * which case a suffix is added to the generated field.
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3109 */
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3110 if ((parsingIntrinsic() \|\| graphBuilderConfig.omitAssertions()) && resolvedField.isSynthetic() && resolvedField.getName().startsWith("$assertionsDisabled")) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3111 frameState.push(field.getKind(), ConstantNode.forBoolean(true, graph));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3112 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3113 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3114
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3115 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3116 if (plugin.handleLoadStaticField(this, resolvedField)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3117 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3118 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3119 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3120
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3121 frameState.push(field.getKind(), append(genLoadField(null, resolvedField)));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3122 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3123
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3124 private void genPutStatic(JavaField field) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3125 ValueNode value = frameState.pop(field.getKind());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3126 if (!(field instanceof ResolvedJavaField) \|\| !((ResolvedJavaType) field.getDeclaringClass()).isInitialized()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3127 handleUnresolvedStoreField(field, value, null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3128 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3129 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3130 ResolvedJavaField resolvedField = (ResolvedJavaField) field;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3131
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3132 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3133 if (plugin.handleStoreStaticField(this, resolvedField, value)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3134 return;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3135 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3136 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3137
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3138 genStoreField(null, resolvedField, value);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3139 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3140
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3141 private double[] switchProbability(int numberOfCases, int bci) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3142 double[] prob = (profilingInfo == null ? null : profilingInfo.getSwitchProbabilities(bci));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3143 if (prob != null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3144 assert prob.length == numberOfCases;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3145 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3146 Debug.log("Missing probability (switch) in %s at bci %d", method, bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3147 prob = new double[numberOfCases];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3148 for (int i = 0; i < numberOfCases; i++) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3149 prob[i] = 1.0d / numberOfCases;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3150 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3151 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3152 assert allPositive(prob);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3153 return prob;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3154 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3155
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3156 private static boolean allPositive(double[] a) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3157 for (double d : a) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3158 if (d < 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3159 return false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3160 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3161 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3162 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3163 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3164
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3165 static class SuccessorInfo {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3166 final int blockIndex;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3167 int actualIndex;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3168
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3169 public SuccessorInfo(int blockSuccessorIndex) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3170 this.blockIndex = blockSuccessorIndex;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3171 actualIndex = -1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3172 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3173 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3174
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3175 private void genSwitch(BytecodeSwitch bs) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3176 int bci = bci();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3177 ValueNode value = frameState.pop(Kind.Int);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3178
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3179 int nofCases = bs.numberOfCases();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3180 double[] keyProbabilities = switchProbability(nofCases + 1, bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3181
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3182 Map<Integer, SuccessorInfo> bciToBlockSuccessorIndex = new HashMap<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3183 for (int i = 0; i < currentBlock.getSuccessorCount(); i++) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3184 assert !bciToBlockSuccessorIndex.containsKey(currentBlock.getSuccessor(i).startBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3185 if (!bciToBlockSuccessorIndex.containsKey(currentBlock.getSuccessor(i).startBci)) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3186 bciToBlockSuccessorIndex.put(currentBlock.getSuccessor(i).startBci, new SuccessorInfo(i));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3187 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3188 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3189
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3190 ArrayList<BciBlock> actualSuccessors = new ArrayList<>();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3191 int[] keys = new int[nofCases];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3192 int[] keySuccessors = new int[nofCases + 1];
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3193 int deoptSuccessorIndex = -1;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3194 int nextSuccessorIndex = 0;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3195 boolean constantValue = value.isConstant();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3196 for (int i = 0; i < nofCases + 1; i++) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3197 if (i < nofCases) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3198 keys[i] = bs.keyAt(i);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3199 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3200
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3201 if (!constantValue && isNeverExecutedCode(keyProbabilities[i])) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3202 if (deoptSuccessorIndex < 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3203 deoptSuccessorIndex = nextSuccessorIndex++;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3204 actualSuccessors.add(null);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3205 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3206 keySuccessors[i] = deoptSuccessorIndex;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3207 } else {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3208 int targetBci = i >= nofCases ? bs.defaultTarget() : bs.targetAt(i);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3209 SuccessorInfo info = bciToBlockSuccessorIndex.get(targetBci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3210 if (info.actualIndex < 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3211 info.actualIndex = nextSuccessorIndex++;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3212 actualSuccessors.add(currentBlock.getSuccessor(info.blockIndex));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3213 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3214 keySuccessors[i] = info.actualIndex;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3215 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3216 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3217
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3218 genIntegerSwitch(value, actualSuccessors, keys, keyProbabilities, keySuccessors);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3219
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3220 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3221
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3222 protected boolean isNeverExecutedCode(double probability) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3223 return probability == 0 && optimisticOpts.removeNeverExecutedCode();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3224 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3225
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3226 protected double branchProbability() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3227 if (profilingInfo == null) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3228 return 0.5;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3229 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3230 assert assertAtIfBytecode();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3231 double probability = profilingInfo.getBranchTakenProbability(bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3232 if (probability < 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3233 assert probability == -1 : "invalid probability";
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3234 Debug.log("missing probability in %s at bci %d", method, bci());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3235 probability = 0.5;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3236 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3237
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3238 if (!optimisticOpts.removeNeverExecutedCode()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3239 if (probability == 0) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3240 probability = 0.0000001;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3241 } else if (probability == 1) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3242 probability = 0.999999;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3243 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3244 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3245 return probability;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3246 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3247
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3248 private boolean assertAtIfBytecode() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3249 int bytecode = stream.currentBC();
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3250 switch (bytecode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3251 case IFEQ:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3252 case IFNE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3253 case IFLT:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3254 case IFGE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3255 case IFGT:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3256 case IFLE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3257 case IF_ICMPEQ:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3258 case IF_ICMPNE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3259 case IF_ICMPLT:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3260 case IF_ICMPGE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3261 case IF_ICMPGT:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3262 case IF_ICMPLE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3263 case IF_ACMPEQ:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3264 case IF_ACMPNE:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3265 case IFNULL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3266 case IFNONNULL:
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3267 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3268 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3269 assert false : String.format("%x is not an if bytecode", bytecode);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3270 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3271 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3272
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3273 public final void processBytecode(int bci, int opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3274 int cpi;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3275
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3276 // @formatter:off
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3277 // Checkstyle: stop
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3278 switch (opcode) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3279 case NOP : /* nothing to do */ break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3280 case ACONST_NULL : frameState.push(Kind.Object, appendConstant(JavaConstant.NULL_POINTER)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3281 case ICONST_M1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3282 case ICONST_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3283 case ICONST_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3284 case ICONST_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3285 case ICONST_3 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3286 case ICONST_4 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3287 case ICONST_5 : frameState.push(Kind.Int, appendConstant(JavaConstant.forInt(opcode - ICONST_0))); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3288 case LCONST_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3289 case LCONST_1 : frameState.push(Kind.Long, appendConstant(JavaConstant.forLong(opcode - LCONST_0))); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3290 case FCONST_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3291 case FCONST_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3292 case FCONST_2 : frameState.push(Kind.Float, appendConstant(JavaConstant.forFloat(opcode - FCONST_0))); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3293 case DCONST_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3294 case DCONST_1 : frameState.push(Kind.Double, appendConstant(JavaConstant.forDouble(opcode - DCONST_0))); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3295 case BIPUSH : frameState.push(Kind.Int, appendConstant(JavaConstant.forInt(stream.readByte()))); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3296 case SIPUSH : frameState.push(Kind.Int, appendConstant(JavaConstant.forInt(stream.readShort()))); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3297 case LDC : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3298 case LDC_W : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3299 case LDC2_W : genLoadConstant(stream.readCPI(), opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3300 case ILOAD : loadLocal(stream.readLocalIndex(), Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3301 case LLOAD : loadLocal(stream.readLocalIndex(), Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3302 case FLOAD : loadLocal(stream.readLocalIndex(), Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3303 case DLOAD : loadLocal(stream.readLocalIndex(), Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3304 case ALOAD : loadLocal(stream.readLocalIndex(), Kind.Object); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3305 case ILOAD_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3306 case ILOAD_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3307 case ILOAD_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3308 case ILOAD_3 : loadLocal(opcode - ILOAD_0, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3309 case LLOAD_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3310 case LLOAD_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3311 case LLOAD_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3312 case LLOAD_3 : loadLocal(opcode - LLOAD_0, Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3313 case FLOAD_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3314 case FLOAD_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3315 case FLOAD_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3316 case FLOAD_3 : loadLocal(opcode - FLOAD_0, Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3317 case DLOAD_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3318 case DLOAD_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3319 case DLOAD_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3320 case DLOAD_3 : loadLocal(opcode - DLOAD_0, Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3321 case ALOAD_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3322 case ALOAD_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3323 case ALOAD_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3324 case ALOAD_3 : loadLocal(opcode - ALOAD_0, Kind.Object); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3325 case IALOAD : genLoadIndexed(Kind.Int ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3326 case LALOAD : genLoadIndexed(Kind.Long ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3327 case FALOAD : genLoadIndexed(Kind.Float ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3328 case DALOAD : genLoadIndexed(Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3329 case AALOAD : genLoadIndexed(Kind.Object); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3330 case BALOAD : genLoadIndexed(Kind.Byte ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3331 case CALOAD : genLoadIndexed(Kind.Char ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3332 case SALOAD : genLoadIndexed(Kind.Short ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3333 case ISTORE : storeLocal(Kind.Int, stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3334 case LSTORE : storeLocal(Kind.Long, stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3335 case FSTORE : storeLocal(Kind.Float, stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3336 case DSTORE : storeLocal(Kind.Double, stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3337 case ASTORE : storeLocal(Kind.Object, stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3338 case ISTORE_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3339 case ISTORE_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3340 case ISTORE_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3341 case ISTORE_3 : storeLocal(Kind.Int, opcode - ISTORE_0); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3342 case LSTORE_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3343 case LSTORE_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3344 case LSTORE_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3345 case LSTORE_3 : storeLocal(Kind.Long, opcode - LSTORE_0); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3346 case FSTORE_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3347 case FSTORE_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3348 case FSTORE_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3349 case FSTORE_3 : storeLocal(Kind.Float, opcode - FSTORE_0); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3350 case DSTORE_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3351 case DSTORE_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3352 case DSTORE_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3353 case DSTORE_3 : storeLocal(Kind.Double, opcode - DSTORE_0); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3354 case ASTORE_0 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3355 case ASTORE_1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3356 case ASTORE_2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3357 case ASTORE_3 : storeLocal(Kind.Object, opcode - ASTORE_0); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3358 case IASTORE : genStoreIndexed(Kind.Int ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3359 case LASTORE : genStoreIndexed(Kind.Long ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3360 case FASTORE : genStoreIndexed(Kind.Float ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3361 case DASTORE : genStoreIndexed(Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3362 case AASTORE : genStoreIndexed(Kind.Object); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3363 case BASTORE : genStoreIndexed(Kind.Byte ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3364 case CASTORE : genStoreIndexed(Kind.Char ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3365 case SASTORE : genStoreIndexed(Kind.Short ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3366 case POP : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3367 case POP2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3368 case DUP : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3369 case DUP_X1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3370 case DUP_X2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3371 case DUP2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3372 case DUP2_X1 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3373 case DUP2_X2 : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3374 case SWAP : frameState.stackOp(opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3375 case IADD : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3376 case ISUB : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3377 case IMUL : genArithmeticOp(Kind.Int, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3378 case IDIV : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3379 case IREM : genIntegerDivOp(Kind.Int, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3380 case LADD : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3381 case LSUB : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3382 case LMUL : genArithmeticOp(Kind.Long, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3383 case LDIV : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3384 case LREM : genIntegerDivOp(Kind.Long, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3385 case FADD : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3386 case FSUB : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3387 case FMUL : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3388 case FDIV : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3389 case FREM : genArithmeticOp(Kind.Float, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3390 case DADD : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3391 case DSUB : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3392 case DMUL : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3393 case DDIV : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3394 case DREM : genArithmeticOp(Kind.Double, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3395 case INEG : genNegateOp(Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3396 case LNEG : genNegateOp(Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3397 case FNEG : genNegateOp(Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3398 case DNEG : genNegateOp(Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3399 case ISHL : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3400 case ISHR : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3401 case IUSHR : genShiftOp(Kind.Int, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3402 case IAND : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3403 case IOR : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3404 case IXOR : genLogicOp(Kind.Int, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3405 case LSHL : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3406 case LSHR : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3407 case LUSHR : genShiftOp(Kind.Long, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3408 case LAND : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3409 case LOR : // fall through
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3410 case LXOR : genLogicOp(Kind.Long, opcode); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3411 case IINC : genIncrement(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3412 case I2F : genFloatConvert(FloatConvert.I2F, Kind.Int, Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3413 case I2D : genFloatConvert(FloatConvert.I2D, Kind.Int, Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3414 case L2F : genFloatConvert(FloatConvert.L2F, Kind.Long, Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3415 case L2D : genFloatConvert(FloatConvert.L2D, Kind.Long, Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3416 case F2I : genFloatConvert(FloatConvert.F2I, Kind.Float, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3417 case F2L : genFloatConvert(FloatConvert.F2L, Kind.Float, Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3418 case F2D : genFloatConvert(FloatConvert.F2D, Kind.Float, Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3419 case D2I : genFloatConvert(FloatConvert.D2I, Kind.Double, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3420 case D2L : genFloatConvert(FloatConvert.D2L, Kind.Double, Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3421 case D2F : genFloatConvert(FloatConvert.D2F, Kind.Double, Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3422 case L2I : genNarrow(Kind.Long, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3423 case I2L : genSignExtend(Kind.Int, Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3424 case I2B : genSignExtend(Kind.Byte, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3425 case I2S : genSignExtend(Kind.Short, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3426 case I2C : genZeroExtend(Kind.Char, Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3427 case LCMP : genCompareOp(Kind.Long, false); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3428 case FCMPL : genCompareOp(Kind.Float, true); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3429 case FCMPG : genCompareOp(Kind.Float, false); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3430 case DCMPL : genCompareOp(Kind.Double, true); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3431 case DCMPG : genCompareOp(Kind.Double, false); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3432 case IFEQ : genIfZero(Condition.EQ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3433 case IFNE : genIfZero(Condition.NE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3434 case IFLT : genIfZero(Condition.LT); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3435 case IFGE : genIfZero(Condition.GE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3436 case IFGT : genIfZero(Condition.GT); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3437 case IFLE : genIfZero(Condition.LE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3438 case IF_ICMPEQ : genIfSame(Kind.Int, Condition.EQ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3439 case IF_ICMPNE : genIfSame(Kind.Int, Condition.NE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3440 case IF_ICMPLT : genIfSame(Kind.Int, Condition.LT); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3441 case IF_ICMPGE : genIfSame(Kind.Int, Condition.GE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3442 case IF_ICMPGT : genIfSame(Kind.Int, Condition.GT); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3443 case IF_ICMPLE : genIfSame(Kind.Int, Condition.LE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3444 case IF_ACMPEQ : genIfSame(Kind.Object, Condition.EQ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3445 case IF_ACMPNE : genIfSame(Kind.Object, Condition.NE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3446 case GOTO : genGoto(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3447 case JSR : genJsr(stream.readBranchDest()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3448 case RET : genRet(stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3449 case TABLESWITCH : genSwitch(new BytecodeTableSwitch(getStream(), bci())); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3450 case LOOKUPSWITCH : genSwitch(new BytecodeLookupSwitch(getStream(), bci())); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3451 case IRETURN : genReturn(frameState.pop(Kind.Int), Kind.Int); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3452 case LRETURN : genReturn(frameState.pop(Kind.Long), Kind.Long); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3453 case FRETURN : genReturn(frameState.pop(Kind.Float), Kind.Float); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3454 case DRETURN : genReturn(frameState.pop(Kind.Double), Kind.Double); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3455 case ARETURN : genReturn(frameState.pop(Kind.Object), Kind.Object); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3456 case RETURN : genReturn(null, Kind.Void); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3457 case GETSTATIC : cpi = stream.readCPI(); genGetStatic(lookupField(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3458 case PUTSTATIC : cpi = stream.readCPI(); genPutStatic(lookupField(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3459 case GETFIELD : cpi = stream.readCPI(); genGetField(lookupField(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3460 case PUTFIELD : cpi = stream.readCPI(); genPutField(lookupField(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3461 case INVOKEVIRTUAL : cpi = stream.readCPI(); genInvokeVirtual(lookupMethod(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3462 case INVOKESPECIAL : cpi = stream.readCPI(); genInvokeSpecial(lookupMethod(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3463 case INVOKESTATIC : cpi = stream.readCPI(); genInvokeStatic(lookupMethod(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3464 case INVOKEINTERFACE: cpi = stream.readCPI(); genInvokeInterface(lookupMethod(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3465 case INVOKEDYNAMIC : cpi = stream.readCPI4(); genInvokeDynamic(lookupMethod(cpi, opcode)); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3466 case NEW : genNewInstance(stream.readCPI()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3467 case NEWARRAY : genNewPrimitiveArray(stream.readLocalIndex()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3468 case ANEWARRAY : genNewObjectArray(stream.readCPI()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3469 case ARRAYLENGTH : genArrayLength(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3470 case ATHROW : genThrow(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3471 case CHECKCAST : genCheckCast(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3472 case INSTANCEOF : genInstanceOf(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3473 case MONITORENTER : genMonitorEnter(frameState.pop(Kind.Object), stream.nextBCI()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3474 case MONITOREXIT : genMonitorExit(frameState.pop(Kind.Object), null, stream.nextBCI()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3475 case MULTIANEWARRAY : genNewMultiArray(stream.readCPI()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3476 case IFNULL : genIfNull(Condition.EQ); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3477 case IFNONNULL : genIfNull(Condition.NE); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3478 case GOTO_W : genGoto(); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3479 case JSR_W : genJsr(stream.readBranchDest()); break;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3480 case BREAKPOINT : throw new BailoutException("concurrent setting of breakpoint");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3481 default : throw new BailoutException("Unsupported opcode %d (%s) [bci=%d]", opcode, nameOf(opcode), bci);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3482 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3483 // @formatter:on
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3484 // Checkstyle: resume
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3485 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3486
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3487 private void genArrayLength() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3488 frameState.push(Kind.Int, append(genArrayLength(frameState.pop(Kind.Object))));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3489 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3490
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3491 public ResolvedJavaMethod getMethod() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3492 return method;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3493 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3494
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3495 public FrameStateBuilder getFrameStateBuilder() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3496 return frameState;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3497 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3498
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3499 protected boolean traceInstruction(int bci, int opcode, boolean blockStart) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3500 if (Debug.isEnabled() && Options.TraceBytecodeParserLevel.getValue() >= TRACELEVEL_INSTRUCTIONS && Debug.isLogEnabled()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3501 traceInstructionHelper(bci, opcode, blockStart);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3502 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3503 return true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3504 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3505
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3506 private void traceInstructionHelper(int bci, int opcode, boolean blockStart) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3507 StringBuilder sb = new StringBuilder(40);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3508 sb.append(blockStart ? '+' : '\|');
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3509 if (bci < 10) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3510 sb.append(" ");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3511 } else if (bci < 100) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3512 sb.append(' ');
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3513 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3514 sb.append(bci).append(": ").append(Bytecodes.nameOf(opcode));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3515 for (int i = bci + 1; i < stream.nextBCI(); ++i) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3516 sb.append(' ').append(stream.readUByte(i));
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3517 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3518 if (!currentBlock.getJsrScope().isEmpty()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3519 sb.append(' ').append(currentBlock.getJsrScope());
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3520 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3521 Debug.log("%s", sb);
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3522 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3523
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3524 public boolean parsingIntrinsic() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3525 return intrinsicContext != null;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3526 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3527
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3528 public BytecodeParser getNonIntrinsicAncestor() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3529 BytecodeParser ancestor = parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3530 while (ancestor != null && ancestor.parsingIntrinsic()) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3531 ancestor = ancestor.parent;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3532 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3533 return ancestor;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3534 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3535
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3536 static String nSpaces(int n) {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3537 return n == 0 ? "" : format("%" + n + "s", "");
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3538 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3539
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3540 @SuppressWarnings("all")
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3541 private static boolean assertionsEnabled() {
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3542 boolean assertionsEnabled = false;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3543 assert assertionsEnabled = true;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3544 return assertionsEnabled;
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3545 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3546 }

Mercurial > hg > truffle

annotate graal/com.oracle.graal.java/src/com/oracle/graal/java/BytecodeParser.java @ 21609:2221d959de64