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 @ 21771:ed3d7af510bd

BytecodeParser#lookupField: use eagerResolving instead of unresolvedIsError to guard explicit initialization.

author	Josef Eisl <josef.eisl@jku.at>
date	Wed, 03 Jun 2015 09:28:41 +0200
parents	bb72c486714a
children	76c162c69c2f

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
21720 d915361cc3a1 moved asm, bytecode and asm.test code back to com.oracle.graal name space (JBS:GRAAL-53) Doug Simon <doug.simon@oracle.com> parents: 21713 diff changeset	25 import static com.oracle.graal.bytecode.Bytecodes.*;
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	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
21720 d915361cc3a1 moved asm, bytecode and asm.test code back to com.oracle.graal name space (JBS:GRAAL-53) Doug Simon <doug.simon@oracle.com> parents: 21713 diff changeset	40 import com.oracle.graal.bytecode.*;
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	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)//
21622 45dea3e24169 Enable inlining during parsing by default. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21621 diff changeset	80 public static final StableOptionValue<Boolean> InlineDuringParsing = new StableOptionValue<>(true);
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	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
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	368 /*
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	369 * Configure the assertion checking behavior of the FrameStateBuilder. This needs to be
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	370 * done only when assertions are enabled, so it is wrapped in an assertion itself.
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	371 */
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	372 assert computeKindVerification(startFrameState);
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	373
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	374 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	375 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	376 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	377 } 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	378 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	379 }
2221d959de64 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
2221d959de64 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 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	382 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	383 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	384
2221d959de64 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 BciBlock startBlock = blockMap.getStartBlock();
21621 993853d22c14 Fix in the bytecode parser: Do not overwrite the stateAfter of the start instruction. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21611 diff changeset	386 if (this.parent == null) {
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	387 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	388 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	389 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	390 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	391 } 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	392 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	393 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	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 * 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	396 * 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	397 */
2221d959de64 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 } 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	399 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	400 }
2221d959de64 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 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	402 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	403 } 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	404 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	405 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	406 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	407 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	413 // 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	414 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	415 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	416 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	417 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	418 }
2221d959de64 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
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	420 finishPrepare(lastInstr);
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	421
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	422 if (graphBuilderConfig.insertNonSafepointDebugInfo() && !parsingIntrinsic()) {
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	423 genInfoPointNode(InfopointReason.METHOD_START, null);
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	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 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	427 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	428 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	429 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	430 } 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	431 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	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
2221d959de64 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 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	435 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	436 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	437 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	438 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	439 }
2221d959de64 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 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	442 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	443 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	444 }
2221d959de64 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
2221d959de64 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 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	447 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	448 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	452 private boolean computeKindVerification(FrameStateBuilder startFrameState) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	453 if (blockMap.hasJsrBytecodes) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	454 /*
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	455 * The JSR return address is an int value, but stored using the astore bytecode. Instead
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	456 * of weakening the kind assertion checking for all methods, we disable it completely
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	457 * for methods that contain a JSR bytecode.
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	458 */
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	459 startFrameState.disableKindVerification();
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	460 }
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	461
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	462 for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	463 if (plugin.canChangeStackKind(this)) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	464 /*
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	465 * We have a plugin that can change the kind of values, so no kind assertion
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	466 * checking is possible.
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	467 */
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	468 startFrameState.disableKindVerification();
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	469 }
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	470 }
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	471 return true;
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	472 }
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	473
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	474 /**
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	475 * Hook for subclasses to modify the graph start instruction or append new instructions to it.
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	476 *
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	477 * @param startInstr the start instruction of the graph
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	478 */
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	479 protected void finishPrepare(FixedWithNextNode startInstr) {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	480 }
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	481
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	482 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	483 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	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 // 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	486 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	487 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	488 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	489 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	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
2221d959de64 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 // 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	494 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	495 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	496 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	497 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	498 // 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	499 } 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	500 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	501 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	502 }
2221d959de64 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 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	504 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	505 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 /**
2221d959de64 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 * 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	511 * 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	512 */
2221d959de64 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 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	514 // 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	515 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	516 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	517 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	518 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	519 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	520 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	521 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	522 }
2221d959de64 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 } 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	524 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	525 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	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 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	528 }
2221d959de64 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
2221d959de64 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 // 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	531 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	532 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	533 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	534 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	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 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	537 }
2221d959de64 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
2221d959de64 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 /**
2221d959de64 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 * 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	541 * 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	542 */
2221d959de64 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 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	544 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	545 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	546 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	547 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	548 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	549 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	550 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	551 } 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	552 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	553 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	554 if (original.getMaxLocals() == frameState.localsSize() \|\| original.isNative()) {
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	555 locals = new ValueNode[original.getMaxLocals()];
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	556 for (int i = 0; i < locals.length; i++) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	557 ValueNode node = frameState.locals[i];
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	558 if (node == FrameState.TWO_SLOT_MARKER) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	559 node = null;
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	560 }
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	561 locals[i] = node;
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	562 }
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	563 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	564 } 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	565 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	566 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	567 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	568 ValueNode param = frameState.locals[i];
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	569 if (param == FrameState.TWO_SLOT_MARKER) {
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	570 param = null;
c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	571 }
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	572 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	573 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	574 }
2221d959de64 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 }
2221d959de64 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 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	577 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	578 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	579 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	580 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	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 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	583 }
2221d959de64 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 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	586 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	587 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	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 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	592 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	593 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	594 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	595 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	596 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	597 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	598 }
2221d959de64 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 } 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	600 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	601 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	602 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	603 // 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	604 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	605 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	606 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	607 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	608 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	609 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	610 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	611 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	612 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	613 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	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 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	616 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	617 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	618 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	619 }
2221d959de64 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 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	621 } 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	622 // 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	623 } 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	624 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	625 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	626 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	632 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	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
2221d959de64 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 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	636 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	637 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	638 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	639 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	640 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	641 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	642 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	643 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	644 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	645 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	646 }
2221d959de64 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 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	648 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	649 // 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	650 } 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	651 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	652 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	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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	658 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	659 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	660 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	661 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	662 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	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
2221d959de64 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 // 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	667 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	668 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	669 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	670 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	671 }
2221d959de64 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 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	676 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	677 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	678 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	679 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	680 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	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 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	684 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	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 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	687 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	688 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	689 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	690 }
2221d959de64 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 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	692 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	693 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	694 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	695 // 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	696 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	697 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	698 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	699 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	700 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	701 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	702 }
2221d959de64 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 } 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	704 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	705 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	706 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	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 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	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 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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 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	715 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	716 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	717 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	718 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	719 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	720 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	721 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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 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	726 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	727 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	728 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	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 }
2221d959de64 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
2221d959de64 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 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	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
2221d959de64 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 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	736 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	737 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	738 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	739 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	740 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	741 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	742 }
2221d959de64 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 }
2221d959de64 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 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	746 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	747 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	751 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	752 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	753 } 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	754 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	755 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	756 }
2221d959de64 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 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	760 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	761 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	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 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	765 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	766 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	767 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	768 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	769 }
2221d959de64 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 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	771 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	772 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	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 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	775 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	776 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	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
2221d959de64 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 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	780 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	781 }
2221d959de64 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 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	784 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	785 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	786 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	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 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	789 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	790 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	791 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	792 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	793 }
2221d959de64 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
2221d959de64 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 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	796 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	797 // 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	798 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	799 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	800 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	801 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	802 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	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 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	805 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	806 }
2221d959de64 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 }
2221d959de64 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 } 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	809 // 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	810 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	811 }
2221d959de64 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 /**
2221d959de64 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 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	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 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	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 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	825 * @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	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 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	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 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	830 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	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 /**
2221d959de64 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 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	835 * @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	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 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	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 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	840 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	841 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	842 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	843 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	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
2221d959de64 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 /**
2221d959de64 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 * @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	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 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	850 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	851 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	852 }
2221d959de64 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 /**
2221d959de64 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 * @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	856 * @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	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 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	859 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	860 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	861 }
2221d959de64 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 /**
2221d959de64 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 * @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	865 * @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	866 */
2221d959de64 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 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	868 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	869 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	870 }
2221d959de64 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 * @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	874 * @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	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 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	877 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	878 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	879 }
2221d959de64 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
2221d959de64 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 /**
2221d959de64 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 * @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	883 * @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	884 * @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	885 */
2221d959de64 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 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	887 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	888 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	889 }
2221d959de64 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
2221d959de64 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 /**
2221d959de64 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 * @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	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 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	895 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	896 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	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 /**
2221d959de64 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 * @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	901 * @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	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 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	904 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	905 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	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
2221d959de64 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 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	909 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	910 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	911
2221d959de64 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 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	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 * 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	915 * 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	916 * 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	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 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	919 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	920 }
2221d959de64 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 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	923 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	924
2221d959de64 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 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	926 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	927 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	928 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	929 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	930 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	931 } 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	932 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	933 dispatchState.push(Kind.Object, exceptionObject);
21751 1524f4f7894d fix rethrowException flag in exception dispatch state Andreas Woess <andreas.woess@oracle.com> parents: 21720 diff changeset	934 dispatchState.setRethrowException(true);
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	935 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	936 }
2221d959de64 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 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	938 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	939 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	940 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	941 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	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
2221d959de64 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 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	945 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	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
2221d959de64 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 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	949 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	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
2221d959de64 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 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	953 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	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
2221d959de64 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 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	957 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	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
2221d959de64 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 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	961 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	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
2221d959de64 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 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	965 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	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
2221d959de64 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 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	969 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	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
2221d959de64 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 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	973 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	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
2221d959de64 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 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	977 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	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
2221d959de64 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 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	981 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	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
2221d959de64 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 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	985 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	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
2221d959de64 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 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	989 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	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
2221d959de64 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 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	993 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	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 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	997 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	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 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	1001 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	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 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	1005 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	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 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	1009 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	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 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	1013 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	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 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	1017 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	1018 }
2221d959de64 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
2221d959de64 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 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	1021 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	1022 }
2221d959de64 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
2221d959de64 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 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	1025 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	1026 }
2221d959de64 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
2221d959de64 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 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	1029 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	1030 }
2221d959de64 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
2221d959de64 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 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	1033 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	1034 }
2221d959de64 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
2221d959de64 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 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	1037 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	1038 }
2221d959de64 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
2221d959de64 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 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	1041 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	1042 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	1043 }
2221d959de64 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 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	1046 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	1047 }
2221d959de64 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 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	1050 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	1051 }
2221d959de64 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
2221d959de64 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 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	1054 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	1055 }
2221d959de64 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
2221d959de64 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 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	1058 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	1059 }
2221d959de64 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 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	1062 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	1063 }
2221d959de64 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 protected void genThrow() {
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	1066 genInfoPointNode(InfopointReason.LINE_NUMBER, null);
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	1067
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	1068 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	1069 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	1070 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	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
2221d959de64 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 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	1074 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	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
2221d959de64 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 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	1078 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	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
2221d959de64 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 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	1082 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	1083 }
2221d959de64 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 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	1086 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	1087 }
2221d959de64 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
2221d959de64 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 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	1090 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	1091 }
2221d959de64 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 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	1094 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	1095 }
2221d959de64 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
2221d959de64 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 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	1098 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	1099 }
2221d959de64 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 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	1102 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	1103 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	1104 }
2221d959de64 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 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	1106 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	1107 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	1108 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	1109 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	1110 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	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 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	1113 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	1114 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	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 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	1118 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	1119 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	1120 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	1121 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	1122
2221d959de64 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 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	1124 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	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
2221d959de64 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 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	1128 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	1129 }
2221d959de64 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
2221d959de64 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 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	1132 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	1133 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	1134 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	1135 }
2221d959de64 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 * 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	1139 * 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	1140 *
2221d959de64 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 * @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	1142 * @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	1143 */
2221d959de64 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 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	1145 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	1146 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	1147 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	1148 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	1149 }
2221d959de64 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 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	1151 }
2221d959de64 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
2221d959de64 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 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	1154 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	1155 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	1156 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	1157 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	1158 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	1159 } 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	1160 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	1161 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	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 } 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	1164 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	1165 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	1169 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	1170 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	1171 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	1172 } 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	1173 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	1174 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	1178 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	1179 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	1180 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	1181 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	1182 }
2221d959de64 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 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	1184 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	1185 } 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	1186 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	1187 }
2221d959de64 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
2221d959de64 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 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	1191 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	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 * 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	1194 * 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	1195 * 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	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 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	1198 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	1199 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	1200 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	1201 }
2221d959de64 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 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	1203 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	1204 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	1205 } 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	1206 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	1207 }
2221d959de64 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 } 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	1209 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	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
2221d959de64 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 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	1215 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	1216 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	1217 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	1218 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	1219 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	1220 } 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	1221 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	1222 }
2221d959de64 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
2221d959de64 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 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	1226 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	1227 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	1228 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	1229 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	1230 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	1231 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	1232 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	1233 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	1234 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	1235 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	1236 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	1237 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	1238 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	1239
2221d959de64 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 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	1241 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	1242 }
2221d959de64 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 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	1245 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	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
2221d959de64 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 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	1249 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	1250 }
2221d959de64 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 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	1253 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	1254 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	1255 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	1256 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	1257 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	1258 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	1259 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	1260 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	1261 }
2221d959de64 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 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	1265 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	1266 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	1267 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	1268 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	1269 }
2221d959de64 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
2221d959de64 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 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	1272 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	1273 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	1274 }
2221d959de64 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 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	1276 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	1277 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	1278 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	1279 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	1280 }
2221d959de64 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 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	1283 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	1284 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	1285 }
2221d959de64 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 }
2221d959de64 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 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	1289 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	1290 currentInvokeKind = invokeKind;
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	1291 if (tryNodePluginForInvocation(args, targetMethod)) {
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	1292 if (TraceParserPlugins.getValue()) {
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	1293 traceWithContext("used node plugin for %s", targetMethod.format("%h.%n(%p)"));
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	1294 }
2221d959de64 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 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	1296 }
2221d959de64 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 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	1299 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	1300 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	1301 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	1302 }
2221d959de64 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 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	1304 }
2221d959de64 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
2221d959de64 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 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	1307 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	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 } 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	1311 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	1312 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	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
2221d959de64 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 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	1316
2221d959de64 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 // 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	1318 // 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	1319 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	1320 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	1321 (!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	1322 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	1323 } 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	1324 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	1325 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	1326 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	1327 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	1328 }
2221d959de64 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
2221d959de64 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 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	1331 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	1332 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 * 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	1337 * {@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	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 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	1340 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	1341 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	1342 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	1343 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	1344 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	1345 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	1346 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	1347 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	1348
2221d959de64 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 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	1350 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	1351 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	1352 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	1353 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	1354 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	1355 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	1356 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	1357 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	1358 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	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 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	1362 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	1363 }
2221d959de64 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
2221d959de64 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 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	1366 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	1367 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	1368 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	1369 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	1370 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	1371 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	1372 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	1373 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	1374 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	1375 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	1376 }
2221d959de64 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 }
2221d959de64 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 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	1379 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	1380 } 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	1381 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	1382 }
2221d959de64 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 } 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	1384 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	1385 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	1386 }
2221d959de64 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 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	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 }
2221d959de64 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
2221d959de64 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 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	1392 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	1393 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	1394
2221d959de64 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 (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	1396 // 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	1397 // 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	1398 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	1399 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	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 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	1403 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	1404 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	1405 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	1406 }
2221d959de64 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 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	1408 }
2221d959de64 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 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	1410 }
2221d959de64 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
21683 c74d3c9b9de7 Use a marker value in second slot of a two-slot value during parsing; improve assertion checking in FrameStateBuilder Christian Wimmer <christian.wimmer@oracle.com> parents: 21660 diff changeset	1412 private boolean tryNodePluginForInvocation(ValueNode[] args, ResolvedJavaMethod targetMethod) {
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	1413 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	1414 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	1415 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	1416 }
2221d959de64 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 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	1419 }
2221d959de64 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 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	1422 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	1423 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	1424 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	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 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	1427 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	1428 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	1429 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	1430 /* 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	1431 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	1432 } 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	1433 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	1434 }
2221d959de64 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 }
2221d959de64 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 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	1438 }
2221d959de64 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 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	1441 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	1442 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	1443 }
2221d959de64 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 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	1446 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	1447 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	1448 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	1449 } 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	1450 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	1451 }
2221d959de64 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 }
2221d959de64 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 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	1454 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	1455 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	1456 // 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	1457 // 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	1458 // 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	1459 // 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	1460 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	1461 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	1462 } 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	1463 // 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	1464 // 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	1465 // 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	1466 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	1467 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	1468 }
2221d959de64 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 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	1470 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	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 } 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	1473 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	1474 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	1475 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	1476 }
2221d959de64 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 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	1478 for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
21701 8b03b940c29d InlineInvokePlugin#notify{Before,After}Inline should be called with inlinedMethod Andreas Woess <andreas.woess@oracle.com> parents: 21683 diff changeset	1479 plugin.notifyBeforeInline(inlinedMethod);
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	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 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	1482 for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
21701 8b03b940c29d InlineInvokePlugin#notify{Before,After}Inline should be called with inlinedMethod Andreas Woess <andreas.woess@oracle.com> parents: 21683 diff changeset	1483 plugin.notifyAfterInline(inlinedMethod);
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	1484 }
2221d959de64 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 } 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	1486 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	1487 }
2221d959de64 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 }
2221d959de64 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 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	1490 }
2221d959de64 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 * 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	1494 * 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	1495 *
2221d959de64 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 * <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	1497 * {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	1498 * </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	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 * 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	1501 *
2221d959de64 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 * @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	1503 * @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	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 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	1507 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	1508 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	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
2221d959de64 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 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	1512 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	1513 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	1514 }
2221d959de64 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 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	1516 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	1517 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	1518 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	1519 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	1520 }
2221d959de64 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 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	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
2221d959de64 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 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	1525 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	1526
2221d959de64 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 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	1528 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	1529 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	1530 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	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 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	1533 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	1534
2221d959de64 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 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	1536 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	1537 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	1538 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	1539 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	1540 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	1541 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	1542 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	1546 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	1547 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	1548 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	1549 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	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
2221d959de64 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 // 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	1553 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	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
2221d959de64 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 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	1558 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	1559 }
2221d959de64 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
2221d959de64 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 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	1562 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	1563 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	1564 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	1565 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	1566 }
2221d959de64 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
2221d959de64 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 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	1569 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	1570 /*
2221d959de64 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 * 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	1572 * 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	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 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	1575 }
2221d959de64 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 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	1578 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	1579 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	1580 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	1581 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	1582 }
2221d959de64 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 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	1585 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	1586 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	1587 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	1588 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	1589 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	1590 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	1591 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	1592 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	1593 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	1594 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	1595 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	1596 } 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	1597 /*
2221d959de64 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 * 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	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 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	1601 }
2221d959de64 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 } 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	1603 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	1604 }
2221d959de64 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 }
2221d959de64 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 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	1608 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	1609 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	1610 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	1611 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	1612 } 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	1613 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	1614 // 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	1615 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	1616 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	1617 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	1618 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	1619 } 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	1620 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	1621 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	1622 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	1623 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	1624 }
2221d959de64 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 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	1626 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	1627 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	1632 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	1633 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	1634 }
2221d959de64 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 if (graphBuilderConfig.insertNonSafepointDebugInfo() && !parsingIntrinsic()) {
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	1636 genInfoPointNode(InfopointReason.METHOD_END, x);
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	1637 }
2221d959de64 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 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	1640 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	1641 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	1642 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	1646 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	1647 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	1648 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	1649 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	1650 }
2221d959de64 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
2221d959de64 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 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	1653 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	1654 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	1655 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	1656 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	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 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	1659 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	1660 }
2221d959de64 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
2221d959de64 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 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	1663 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	1664 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	1665 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	1666 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	1667 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	1668 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	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 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	1671 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	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 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	1674 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	1675 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	1676 }
2221d959de64 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
2221d959de64 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 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	1679 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	1680 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	1681 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	1682 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	1683 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	1684 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	1685 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	1686 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	1687 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	1688 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	1689 }
2221d959de64 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 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	1691 }
2221d959de64 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 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	1694 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	1695 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	1696 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	1697 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	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 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	1701 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	1702 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	1703 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	1704 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	1705 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	1706 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	1707 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	1708 }
2221d959de64 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 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	1711 } 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	1712 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	1713 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	1714 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	1715 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	1716 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	1717 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 * 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	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 * @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	1725 */
2221d959de64 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 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	1727 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	1728 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	1729 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	1730 }
2221d959de64 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 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	1732 }
2221d959de64 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
2221d959de64 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 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	1735 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	1736 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	1737 }
2221d959de64 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
2221d959de64 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 @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	1740 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	1741 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	1742 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	1743 }
2221d959de64 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 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	1745 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	1746 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	1747 }
2221d959de64 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 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	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 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	1752 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	1753 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	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 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	1756 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	1757 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	1758 }
2221d959de64 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 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	1760 }
2221d959de64 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 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	1763 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	1764 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	1765 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	1766 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	1767 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	1768 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	1769 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	1770 } 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	1771 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	1772 }
2221d959de64 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
2221d959de64 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 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	1777 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	1778 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	1779 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	1780 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	1781 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	1782
2221d959de64 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 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	1784 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	1785 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	1786 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	1787 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	1788 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	1789 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	1790 }
2221d959de64 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 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	1792 } 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	1793
2221d959de64 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 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	1795
2221d959de64 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 @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	1797 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	1798 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	1799 }
2221d959de64 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 });
2221d959de64 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
2221d959de64 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 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	1803 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	1804 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	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 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	1807 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	1808 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	1809 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	1810 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	1811 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	1812 }
2221d959de64 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 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	1814 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	1815 }
2221d959de64 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 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	1817 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	1818 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	1819 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	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
2221d959de64 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 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	1823 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	1824 }
2221d959de64 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 }
2221d959de64 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 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	1827 }
2221d959de64 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
2221d959de64 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 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	1830 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	1831 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	1832 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	1833 } 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	1834 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	1835 }
2221d959de64 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
2221d959de64 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 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	1839 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	1840 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	1841 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	1842 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	1843 }
2221d959de64 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 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	1845 } 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	1846 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	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
2221d959de64 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 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	1851 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	1852 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	1853 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	1854 } 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	1855 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	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
2221d959de64 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 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	1860 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	1861 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	1862 }
2221d959de64 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 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	1864 // 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	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 // 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	1867 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	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 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	1870 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	1871 }
2221d959de64 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 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	1873 }
2221d959de64 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
2221d959de64 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 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	1876 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	1877 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	1878 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	1879 } 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	1880 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	1881 }
2221d959de64 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 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	1885 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	1886 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	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 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	1889 // 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	1890 } 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	1891 // 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	1892 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	1893 }
2221d959de64 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 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	1895 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	1896 }
2221d959de64 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 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	1898 }
2221d959de64 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
2221d959de64 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 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	1901 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	1902 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	1903 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	1904 } 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	1905 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	1906 }
2221d959de64 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 }
2221d959de64 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 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	1910 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	1911 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	1912 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	1913 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	1914 }
2221d959de64 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 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	1916 } 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	1917 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	1918 }
2221d959de64 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 }
2221d959de64 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 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	1922 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	1923 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	1924 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	1925 } 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	1926 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	1927 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	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 }
2221d959de64 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
2221d959de64 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 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	1932 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	1933 }
2221d959de64 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
2221d959de64 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 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	1936 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	1937 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	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 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	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 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	1942 /*
2221d959de64 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 * 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	1944 * 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	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 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	1947 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	1948 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	1949 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	1950 } 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	1951 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	1952 }
2221d959de64 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 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	1954 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	1955 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	1956 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	1957 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	1958 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	1959
2221d959de64 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 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	1961 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	1962 }
2221d959de64 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 // 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	1965 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	1966 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	1967 }
2221d959de64 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
2221d959de64 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 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	1970 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	1971 /*
2221d959de64 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 * 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	1973 * 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	1974 */
2221d959de64 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 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	1976 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	1977 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	1978 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	1979 }
2221d959de64 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 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	1981 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	1982 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	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 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	1985 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	1986 }
2221d959de64 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 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	1988 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	1989
2221d959de64 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 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	1991 /*
2221d959de64 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 * 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	1993 * 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	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 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	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 // 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	1998 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	1999 // 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	2000 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	2001 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	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 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	2004 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	2005 } 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	2006 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	2007 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	2008 }
2221d959de64 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 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	2011 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	2012
2221d959de64 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 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	2014 }
2221d959de64 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
2221d959de64 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 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	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 // 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	2019 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	2020 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	2021 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	2022 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	2023 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	2024
2221d959de64 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 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	2026 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	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
2221d959de64 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 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	2030 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	2031 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	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 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	2034 }
2221d959de64 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 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	2037 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	2038 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	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 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	2041 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	2042 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	2043 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	2044 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	2045 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 // 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	2049 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	2050 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	2051 } 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	2052 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	2053 }
2221d959de64 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
2221d959de64 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 // 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	2056 // 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	2057 // 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	2058 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	2059 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	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 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	2062 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	2063 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	2064 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	2065 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	2066 } 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	2067 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	2068 }
2221d959de64 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 }
2221d959de64 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 // 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	2072 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	2073 } 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	2074 // 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	2075 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	2076 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 // 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	2080 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	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 * 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	2085 * 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	2086 */
2221d959de64 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 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	2088 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	2089 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	2090
2221d959de64 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 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	2092 + "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	2093 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	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 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	2097 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	2098 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	2099 } 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	2100 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	2101 }
2221d959de64 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 }
2221d959de64 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 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	2105 // 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	2106 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	2107 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	2108 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	2109 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	2110 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	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 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	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 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	2115 frameState = getEntryState(block, currentDimension);
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2116 frameState.cleanDeletedNodes();
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	2117 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	2118 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	2119
2221d959de64 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 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	2121 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	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
2221d959de64 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 (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	2125 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	2126 } 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	2127 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	2128 } 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	2129 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	2130 } 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	2131 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	2132 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	2133 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2138 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	2139 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	2140 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	2141 } 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	2142 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	2143 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	2144 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	2145 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2149 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	2150 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	2151 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	2152 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	2153 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	2154 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	2155 }
2221d959de64 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 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	2158 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	2159 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	2160 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	2161 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	2162 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	2163 }
2221d959de64 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 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	2165 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2169 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	2170 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	2171 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	2172 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	2173 }
2221d959de64 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 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	2176 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	2177 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	2178 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	2179 }
2221d959de64 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 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	2181 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	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
2221d959de64 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 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	2186 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	2187 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	2188 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	2189 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	2190 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	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
2221d959de64 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 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	2194 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	2195 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	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 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	2198 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	2199 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	2200 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	2201 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	2202 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	2203 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	2204 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	2205 FixedNode nextDispatch = createTarget(nextBlock, frameState);
21765 a7a1b9b65bce Small improvement and clean up of InstanceOfNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21751 diff changeset	2206 append(new IfNode(graph.unique(InstanceOfNode.create((ResolvedJavaType) catchType, exception, null)), trueSuccessor, nextDispatch, 0));
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	2207 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	2208 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2213 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	2214 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	2215 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	2216 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	2217 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	2218 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	2219 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	2220 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	2221 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	2222 checkCast.setNext(catchSuccessor);
21766 bb72c486714a Lower TypeCheck node in first lowering. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21765 diff changeset	2223 append(new IfNode(graph.unique(InstanceOfNode.create((ResolvedJavaType) catchType, exception, null)), checkCast, nextDispatch, 0.5));
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	2224 } 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	2225 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	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 }
2221d959de64 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
2221d959de64 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 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	2230 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	2231 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	2232 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	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 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	2237 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	2238 // 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	2239 // 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	2240 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	2241 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	2242 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	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 // 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	2245 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	2246 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	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 * 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	2250 * 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	2251 */
2221d959de64 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 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	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 * 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	2255 * 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	2256 */
2221d959de64 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 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	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 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	2260 } 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	2261 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	2262 }
2221d959de64 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 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	2264 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	2265
2221d959de64 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 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	2267
2221d959de64 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 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	2269
2221d959de64 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 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	2271 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	2272 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	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 /* 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	2275 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	2276 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	2277 }
2221d959de64 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
2221d959de64 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 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	2280 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	2281 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	2282 if (currentLineNumber != previousLineNumber) {
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2283 genInfoPointNode(InfopointReason.LINE_NUMBER, null);
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	2284 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	2285 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 // 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	2289 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	2290 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	2291 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	2292 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	2293 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	2294 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	2295 }
2221d959de64 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 EntryMarkerNode x = append(new EntryMarkerNode());
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2297 frameState.insertProxies(value -> ProxyNode.forValue(value, x, graph));
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	2298 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	2299 }
2221d959de64 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
2221d959de64 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 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	2302 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	2303 } 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	2304 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	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
2221d959de64 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 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	2308 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	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
2221d959de64 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 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	2312 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	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 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	2315 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	2316 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	2317 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	2318 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	2319 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	2320 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	2321 // 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	2322 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	2323 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	2324 }
2221d959de64 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 }
2221d959de64 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 /* 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	2330 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	2331 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	2332 }
2221d959de64 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
2221d959de64 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 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	2335 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	2336 // 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	2337 } 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	2338 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	2339 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	2340 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	2341 }
2221d959de64 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 }
2221d959de64 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 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	2344 }
2221d959de64 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
2221d959de64 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 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	2347 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	2348 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	2349 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	2350 // 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	2351 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	2352 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	2353 }
2221d959de64 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
2221d959de64 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 /**
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2356 * Hook for subclasses to modify the last instruction or add other instructions.
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	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 * @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	2359 * @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	2360 * @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	2361 */
2221d959de64 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 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	2363 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	2364 }
2221d959de64 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
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2366 private void genInfoPointNode(InfopointReason reason, ValueNode escapedReturnValue) {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2367 if (!parsingIntrinsic()) {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2368 if (graphBuilderConfig.insertFullDebugInfo()) {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2369 append(new FullInfopointNode(reason, createFrameState(bci(), null), escapedReturnValue));
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2370 } else {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2371 BytecodePosition position = createBytecodePosition();
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2372 // Update the previous infopoint position if no new fixed nodes were inserted
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2373 if (lastInstr instanceof SimpleInfopointNode) {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2374 SimpleInfopointNode lastInfopoint = (SimpleInfopointNode) lastInstr;
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2375 if (lastInfopoint.getReason() == reason) {
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2376 lastInfopoint.setPosition(position);
d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2377 }
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	2378 }
21611 d246f7b59166 Make BytecodeParser more extensible Christian Wimmer <christian.wimmer@oracle.com> parents: 21609 diff changeset	2379 append(new SimpleInfopointNode(reason, position));
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	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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2385 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	2386 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	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 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	2389 }
2221d959de64 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
2221d959de64 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 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	2392 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	2393 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	2394 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	2395 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	2396 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	2397 // 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	2398 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	2399 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	2400 }
2221d959de64 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
2221d959de64 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 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	2403 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	2404
2221d959de64 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 // 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	2406 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	2407 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	2408 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	2409 }
2221d959de64 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
2221d959de64 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 // 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	2412 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	2413
2221d959de64 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 // 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	2415 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	2416
2221d959de64 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 // 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	2418 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	2419 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	2420 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	2421 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	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 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	2425 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	2426 } 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	2427 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	2428 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	2429 }
2221d959de64 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
2221d959de64 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 // 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	2432 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	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 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	2435 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	2436 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	2437 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	2438 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	2439 }
2221d959de64 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
2221d959de64 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 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	2442 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	2443 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	2444 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	2445 } 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	2446 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	2447 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	2448 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	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 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	2452 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	2453 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	2454 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	2455 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	2456 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	2457 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	2458 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2463 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	2464 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	2465 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	2466 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	2467 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	2468 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	2469 ((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	2470 } 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	2471 ((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	2472 }
2221d959de64 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 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2478 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	2479 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	2480 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	2481 } 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	2482 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	2483 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	2484 }
2221d959de64 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 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	2486 }
2221d959de64 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 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	2489 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	2490 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	2491 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	2492 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	2493 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	2494 }
2221d959de64 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 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	2496 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	2497 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	2498 } 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	2499 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	2500 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	2501 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	2502 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2506 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	2507 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	2508 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	2509 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	2510 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	2511 } 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	2512 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	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 } 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	2515 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	2516 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	2517 }
2221d959de64 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 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	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
2221d959de64 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 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	2522 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	2523 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	2524 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	2525 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	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 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	2528 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	2529 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	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 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	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
2221d959de64 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 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	2535 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	2536 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	2537 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	2538 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	2539 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	2540 }
2221d959de64 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 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	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
2221d959de64 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 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	2545 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	2546 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	2547 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	2548 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	2549 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	2550 }
2221d959de64 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
2221d959de64 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 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	2553 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	2554 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	2555 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	2556 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	2557 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	2558 }
2221d959de64 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
2221d959de64 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 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	2561 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	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 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	2565 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	2566 }
2221d959de64 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
2221d959de64 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 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	2569 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	2570 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	2571 }
2221d959de64 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
2221d959de64 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 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	2574 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	2575 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	2576 } 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	2577 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	2578 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2582 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	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
2221d959de64 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 /**
2221d959de64 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 * 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	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 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	2589 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	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 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	2593 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	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 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	2597 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	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 @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	2601 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	2602 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	2603 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	2604 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	2605 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	2606 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	2607 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	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 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	2610 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	2611 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	2612 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	2613 }
2221d959de64 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 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	2615 }
2221d959de64 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
2221d959de64 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 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	2618 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	2619 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	2620 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	2621 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	2622 }
2221d959de64 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
2221d959de64 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 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	2625 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	2626 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	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 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	2629 }
2221d959de64 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
2221d959de64 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 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	2632 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	2633 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	2634 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	2635 }
2221d959de64 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 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	2638 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	2639 }
2221d959de64 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 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	2642 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	2643 }
2221d959de64 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
2221d959de64 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 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	2646 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	2647 }
2221d959de64 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
2221d959de64 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 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	2650 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	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 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	2654 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	2655 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	2656 }
2221d959de64 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
2221d959de64 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 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	2659 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	2660 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	2661 }
2221d959de64 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
2221d959de64 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 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	2664 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	2665
2221d959de64 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 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	2667 // 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	2668 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	2669 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	2670 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	2671 } 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	2672 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	2673 }
2221d959de64 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 } 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	2675 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	2676 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	2677 } 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	2678 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	2679 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2683 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	2684 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	2685
2221d959de64 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 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	2687 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	2688 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	2689 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2693 }
2221d959de64 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
2221d959de64 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 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	2696 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	2697 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	2698 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	2699
2221d959de64 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 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	2701 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	2702 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	2703 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	2707 }
2221d959de64 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
2221d959de64 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 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	2710 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	2711 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	2712 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	2713 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	2714 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	2715 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	2716 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	2717 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	2718 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	2719 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	2720 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	2721 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	2722 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	2723 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	2724 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	2725 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	2726 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	2727 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	2728 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	2729 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	2730 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	2731 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	2732 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	2733 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	2734 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	2735 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	2736 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	2737 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	2738 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	2739 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	2740 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	2741 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	2742 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	2743 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	2744 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	2745 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	2746 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	2747 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	2748 }
2221d959de64 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 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	2750 }
2221d959de64 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
2221d959de64 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 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	2753 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	2754 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	2755 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	2756 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	2757 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	2758 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	2759 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	2760 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	2761 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	2762 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	2763 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	2764 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	2765 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	2766 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	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 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	2769 }
2221d959de64 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
2221d959de64 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 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	2772 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	2773 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	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
2221d959de64 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 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	2777 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	2778 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	2779 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	2780 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	2781 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	2782 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	2783 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	2784 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	2785 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	2786 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	2787 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	2788 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	2789 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	2790 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	2791 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	2792 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	2793 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	2794 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	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 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	2797 }
2221d959de64 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
2221d959de64 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 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	2800 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	2801 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	2802 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	2803 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	2804 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	2805 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	2806 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	2807 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	2808 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	2809 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	2810 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	2811 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	2812 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	2813 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	2814 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	2815 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	2816 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	2817 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	2818 }
2221d959de64 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 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	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
2221d959de64 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 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	2823 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	2824 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	2825 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	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
2221d959de64 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 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	2829 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	2830 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	2831 }
2221d959de64 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 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	2834 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	2835 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	2836 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	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 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	2839 }
2221d959de64 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
2221d959de64 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 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	2842 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	2843 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	2844 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	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 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	2847 }
2221d959de64 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
2221d959de64 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 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	2850 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	2851 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	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 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	2855 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	2856 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	2857 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	2858 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	2859 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	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
2221d959de64 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 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	2863 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	2864 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	2865 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	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
2221d959de64 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 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	2869 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	2870 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	2871 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	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 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	2875 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	2876 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	2877 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	2878 }
2221d959de64 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 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	2881 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	2882 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	2883 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	2884 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	2885 }
2221d959de64 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 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	2888 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	2889 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	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 * 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	2892 * 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	2893 * 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	2894 * 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	2895 */
2221d959de64 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 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	2897 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	2898 }
2221d959de64 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
2221d959de64 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 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	2901 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	2902 JavaField result = constantPool.lookupField(cpi, opcode);
21771 ed3d7af510bd BytecodeParser#lookupField: use eagerResolving instead of unresolvedIsError to guard explicit initialization. Josef Eisl <josef.eisl@jku.at> parents: 21766 diff changeset	2903 if (graphBuilderConfig.eagerResolving()) {
21660 e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2904 assert result instanceof ResolvedJavaField : "Not resolved: " + result;
e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2905 ResolvedJavaType declaringClass = ((ResolvedJavaField) result).getDeclaringClass();
e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2906 if (!declaringClass.isInitialized()) {
e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2907 assert declaringClass.isInterface() : "Declaring class not initialized but not an interface? " + declaringClass;
e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2908 declaringClass.initialize();
e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2909 }
e1ca9b57b63b BytecodeParser#lookupField: explicitly initialize interface if it is the declaring class of the field. Josef Eisl <josef.eisl@jku.at> parents: 21654 diff changeset	2910 }
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	2911 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	2912 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	2913 }
2221d959de64 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 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	2916 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	2917 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	2918 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	2919 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	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
2221d959de64 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 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	2923 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	2924 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	2925 }
2221d959de64 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 }
2221d959de64 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 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	2929 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	2930 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	2931 } 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	2932 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	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 }
2221d959de64 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
2221d959de64 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 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	2937 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	2938 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	2939 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	2940
2221d959de64 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 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	2942 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	2943 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	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 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	2946 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	2947
2221d959de64 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 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	2949 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	2950 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	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 }
2221d959de64 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
2221d959de64 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 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	2955 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	2956 if (profile.getNullSeen().isFalse()) {
21654 cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2957 object = appendNullCheck(object);
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	2958 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	2959 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	2960 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	2961 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	2962 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	2963 } else {
21654 cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2964 FixedGuardNode fixedGuard = append(new FixedGuardNode(typeCheck, DeoptimizationReason.TypeCheckedInliningViolated, DeoptimizationAction.InvalidateReprofile, false));
cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2965 checkCastNode = append(new PiNode(object, StampFactory.exactNonNull(singleType), fixedGuard));
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	2966 }
2221d959de64 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 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	2971 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	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 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	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
21654 cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2976 private ValueNode appendNullCheck(ValueNode object) {
cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2977 IsNullNode isNull = append(new IsNullNode(object));
cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2978 FixedGuardNode fixedGuard = append(new FixedGuardNode(isNull, DeoptimizationReason.NullCheckException, DeoptimizationAction.InvalidateReprofile, true));
cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2979 return append(new PiNode(object, object.stamp().join(StampFactory.objectNonNull()), fixedGuard));
cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2980 }
cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	2981
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	2982 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	2983 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	2984 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	2985 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	2986
2221d959de64 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 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	2988 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	2989 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	2990 }
2221d959de64 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 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	2992 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	2993
2221d959de64 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 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	2995 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	2996 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	2997 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	3001 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	3002 if (profile.getNullSeen().isFalse()) {
21654 cd6b1b2189a0 Remove GuardingPiNode and replace with FixedGuardNode + PiNode. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 21622 diff changeset	3003 object = appendNullCheck(object);
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	3004 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	3005 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	3006 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	3007 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	3008 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	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 }
2221d959de64 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 }
2221d959de64 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 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	3013 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	3014 }
2221d959de64 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 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	3016 }
2221d959de64 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 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	3019 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	3020
2221d959de64 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 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	3022 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	3023 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	3024 }
2221d959de64 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 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	3026
2221d959de64 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 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	3028 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	3029 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	3030 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	3031 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	3032 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	3033 }
2221d959de64 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 }
2221d959de64 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(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	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 /**
2221d959de64 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 * 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	3042 * {@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	3043 *
2221d959de64 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 * @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	3045 * @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	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 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	3048 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	3049 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	3050 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	3051 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	3052 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	3053 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	3054 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	3055 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	3056 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	3057 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	3058 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	3059 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	3060 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	3061 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	3062 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	3063 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	3064 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	3065 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	3066 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	3067 }
2221d959de64 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 }
2221d959de64 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 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	3071 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	3072 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	3073 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	3074 }
2221d959de64 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 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	3077 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	3078 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	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 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	3081 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	3082 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	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 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	3085
2221d959de64 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 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	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
2221d959de64 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 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	3090 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	3091 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	3092 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	3093 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	3094 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	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
2221d959de64 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 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	3098 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	3099 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	3100 }
2221d959de64 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 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	3102
2221d959de64 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 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	3104 }
2221d959de64 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 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	3107 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	3108
2221d959de64 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 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	3110 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	3111 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	3112 }
2221d959de64 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 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	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.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	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(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	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 /**
2221d959de64 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 * @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	3126 * @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	3127 * 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	3128 * @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	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 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	3131 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	3132 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	3133 (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	3134 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	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 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	3138 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	3139 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	3140 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	3141 }
2221d959de64 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 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	3143 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	3144 }
2221d959de64 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
2221d959de64 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 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	3147 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	3148 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	3149
2221d959de64 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 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	3151 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	3152 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	3153 }
2221d959de64 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 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	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 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	3157 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	3158 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	3159 }
2221d959de64 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 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	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 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	3166 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	3167 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	3168 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	3169 }
2221d959de64 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 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	3171
2221d959de64 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 * 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	3174 * 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	3175 */
2221d959de64 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 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	3177 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	3178 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	3179 }
2221d959de64 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
2221d959de64 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 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	3182 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	3183 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	3184 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	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 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	3191 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	3192 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	3193 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	3194 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	3195 }
2221d959de64 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 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	3197
2221d959de64 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 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	3199 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	3200 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	3201 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	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
2221d959de64 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 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	3208 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	3209 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	3210 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	3211 } 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	3212 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	3213 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	3214 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	3215 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	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 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	3219 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	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 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	3223 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	3224 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	3225 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	3226 }
2221d959de64 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 }
2221d959de64 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 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	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
2221d959de64 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 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	3232 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	3233 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	3234
2221d959de64 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 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	3236 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	3237 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	3238 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	3242 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	3243 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	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 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	3246 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	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 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	3249 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	3250 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	3251 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	3252 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	3253 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	3257 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	3258 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	3259 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	3260 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	3261 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	3262 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	3263 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	3264 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	3265 }
2221d959de64 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
2221d959de64 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 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	3268 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	3269 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	3270 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	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 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	3273 } 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	3274 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	3275 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	3276 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	3277 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	3278 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	3279 }
2221d959de64 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 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	3281 }
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	3285
2221d959de64 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 }
2221d959de64 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
2221d959de64 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 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	3289 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	3290 }
2221d959de64 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
2221d959de64 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 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	3293 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	3294 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	3295 }
2221d959de64 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 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	3297 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	3298 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	3299 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	3300 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	3301 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	3302 }
2221d959de64 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
2221d959de64 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 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	3305 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	3306 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	3307 } 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	3308 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	3309 }
2221d959de64 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 }
2221d959de64 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 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	3312 }
2221d959de64 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
2221d959de64 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 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	3315 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	3316 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	3317 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	3318 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	3319 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	3320 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	3321 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	3322 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	3323 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	3324 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	3325 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	3326 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	3327 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	3328 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	3329 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	3330 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	3331 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	3332 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	3333 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	3334 }
2221d959de64 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 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	3336 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	3337 }
2221d959de64 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
2221d959de64 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 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	3340 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	3341
2221d959de64 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 // @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	3343 // 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	3344 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	3345 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	3346 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	3347 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	3348 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	3349 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	3350 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	3351 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	3352 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	3353 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	3354 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	3355 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	3356 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	3357 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	3358 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	3359 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	3360 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	3361 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	3362 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	3363 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	3364 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	3365 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	3366 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	3367 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	3368 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	3369 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	3370 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	3371 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	3372 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	3373 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	3374 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	3375 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	3376 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	3377 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	3378 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	3379 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	3380 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	3381 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	3382 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	3383 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	3384 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	3385 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	3386 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	3387 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	3388 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	3389 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	3390 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	3391 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	3392 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	3393 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	3394 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	3395 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	3396 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	3397 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	3398 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	3399 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	3400 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	3401 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	3402 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	3403 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	3404 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	3405 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	3406 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	3407 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	3408 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	3409 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	3410 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	3411 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	3412 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	3413 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	3414 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	3415 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	3416 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	3417 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	3418 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	3419 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	3420 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	3421 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	3422 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	3423 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	3424 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	3425 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	3426 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	3427 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	3428 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	3429 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	3430 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	3431 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	3432 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	3433 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	3434 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	3435 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	3436 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	3437 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	3438 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	3439 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	3440 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	3441 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	3442 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	3443 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	3444 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	3445 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	3446 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	3447 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	3448 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	3449 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	3450 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	3451 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	3452 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	3453 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	3454 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	3455 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	3456 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	3457 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	3458 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	3459 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	3460 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	3461 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	3462 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	3463 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	3464 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	3465 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	3466 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	3467 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	3468 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	3469 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	3470 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	3471 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	3472 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	3473 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	3474 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	3475 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	3476 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	3477 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	3478 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	3479 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	3480 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	3481 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	3482 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	3483 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	3484 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	3485 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	3486 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	3487 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	3488 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	3489 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	3490 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	3491 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	3492 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	3493 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	3494 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	3495 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	3496 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	3497 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	3498 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	3499 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	3500 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	3501 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	3502 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	3503 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	3504 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	3505 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	3506 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	3507 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	3508 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	3509 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	3510 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	3511 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	3512 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	3513 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	3514 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	3515 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	3516 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	3517 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	3518 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	3519 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	3520 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	3521 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	3522 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	3523 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	3524 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	3525 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	3526 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	3527 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	3528 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	3529 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	3530 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	3531 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	3532 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	3533 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	3534 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	3535 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	3536 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	3537 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	3538 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	3539 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	3540 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	3541 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	3542 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	3543 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	3544 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	3545 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	3546 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	3547 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	3548 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3549 // @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	3550 // 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	3551 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3552
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3553 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	3554 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	3555 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3556
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3557 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	3558 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	3559 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3560
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3561 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	3562 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	3563 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3564
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3565 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	3566 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	3567 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	3568 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3569 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	3570 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3571
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3572 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	3573 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	3574 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	3575 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	3576 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	3577 } 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	3578 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	3579 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3580 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	3581 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	3582 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	3583 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3584 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	3585 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	3586 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3587 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	3588 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3589
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3590 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	3591 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	3592 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3593
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3594 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	3595 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	3596 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	3597 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	3598 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3599 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	3600 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3601
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3602 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	3603 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	3604 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3605
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3606 @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	3607 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	3608 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	3609 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	3610 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	3611 }
2221d959de64 Make BytecodeParser a top-level class to avoid excessive indentation of two class nesting levels Christian Wimmer <christian.wimmer@oracle.com> parents: diff changeset	3612 }

Mercurial > hg > truffle

annotate graal/com.oracle.graal.java/src/com/oracle/graal/java/BytecodeParser.java @ 21771:ed3d7af510bd