9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.phases.common.inlining.info;
  24 
  25 import java.util.ArrayList;
  26 import java.util.List;
  27 
  28 import org.graalvm.compiler.core.common.type.StampFactory;
  29 import org.graalvm.compiler.debug.Debug;
  30 import org.graalvm.compiler.graph.Node;
  31 import org.graalvm.compiler.nodes.AbstractBeginNode;
  32 import org.graalvm.compiler.nodes.AbstractMergeNode;
  33 import org.graalvm.compiler.nodes.BeginNode;
  34 import org.graalvm.compiler.nodes.CallTargetNode.InvokeKind;
  35 import org.graalvm.compiler.nodes.DeoptimizeNode;
  36 import org.graalvm.compiler.nodes.EndNode;
  37 import org.graalvm.compiler.nodes.FixedNode;
  38 import org.graalvm.compiler.nodes.FixedWithNextNode;
  39 import org.graalvm.compiler.nodes.FrameState;
  40 import org.graalvm.compiler.nodes.Invoke;
  41 import org.graalvm.compiler.nodes.InvokeWithExceptionNode;
  42 import org.graalvm.compiler.nodes.MergeNode;
  43 import org.graalvm.compiler.nodes.PhiNode;
  44 import org.graalvm.compiler.nodes.PiNode;
  45 import org.graalvm.compiler.nodes.StructuredGraph;
  46 import org.graalvm.compiler.nodes.ValueNode;
  47 import org.graalvm.compiler.nodes.ValuePhiNode;
  48 import org.graalvm.compiler.nodes.extended.LoadHubNode;
  49 import org.graalvm.compiler.nodes.java.ExceptionObjectNode;

 325     private EconomicSet<Node> inlineSingleMethod(StructuredGraph graph, StampProvider stampProvider, ConstantReflectionProvider constantReflection) {
 326         assert concretes.size() == 1 && inlineableElements.length == 1 && ptypes.size() > 1 && !shouldFallbackToInvoke() && notRecordedTypeProbability == 0;
 327 
 328         AbstractBeginNode calleeEntryNode = graph.add(new BeginNode());
 329 
 330         AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph);
 331         AbstractBeginNode[] successors = new AbstractBeginNode[]{calleeEntryNode, unknownTypeSux};
 332         createDispatchOnTypeBeforeInvoke(graph, successors, false, stampProvider, constantReflection);
 333 
 334         calleeEntryNode.setNext(invoke.asNode());
 335 
 336         return inline(invoke, methodAt(0), inlineableElementAt(0), false);
 337     }
 338 
 339     private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, AbstractBeginNode[] successors, boolean invokeIsOnlySuccessor, StampProvider stampProvider,
 340                     ConstantReflectionProvider constantReflection) {
 341         assert ptypes.size() >= 1;
 342         ValueNode nonNullReceiver = InliningUtil.nonNullReceiver(invoke);
 343         LoadHubNode hub = graph.unique(new LoadHubNode(stampProvider, nonNullReceiver));
 344 
 345         Debug.log("Type switch with %d types", concretes.size());
 346 
 347         ResolvedJavaType[] keys = new ResolvedJavaType[ptypes.size()];
 348         double[] keyProbabilities = new double[ptypes.size() + 1];
 349         int[] keySuccessors = new int[ptypes.size() + 1];
 350         double totalProbability = notRecordedTypeProbability;
 351         for (int i = 0; i < ptypes.size(); i++) {
 352             keys[i] = ptypes.get(i).getType();
 353             keyProbabilities[i] = ptypes.get(i).getProbability();
 354             totalProbability += keyProbabilities[i];
 355             keySuccessors[i] = invokeIsOnlySuccessor ? 0 : typesToConcretes.get(i);
 356             assert keySuccessors[i] < successors.length - 1 : "last successor is the unknownTypeSux";
 357         }
 358         keyProbabilities[keyProbabilities.length - 1] = notRecordedTypeProbability;
 359         keySuccessors[keySuccessors.length - 1] = successors.length - 1;
 360 
 361         // Normalize the probabilities.
 362         for (int i = 0; i < keyProbabilities.length; i++) {
 363             keyProbabilities[i] /= totalProbability;
 364         }
 365 

   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.phases.common.inlining.info;
  24 
  25 import java.util.ArrayList;
  26 import java.util.List;
  27 
  28 import org.graalvm.compiler.core.common.type.StampFactory;

  29 import org.graalvm.compiler.graph.Node;
  30 import org.graalvm.compiler.nodes.AbstractBeginNode;
  31 import org.graalvm.compiler.nodes.AbstractMergeNode;
  32 import org.graalvm.compiler.nodes.BeginNode;
  33 import org.graalvm.compiler.nodes.CallTargetNode.InvokeKind;
  34 import org.graalvm.compiler.nodes.DeoptimizeNode;
  35 import org.graalvm.compiler.nodes.EndNode;
  36 import org.graalvm.compiler.nodes.FixedNode;
  37 import org.graalvm.compiler.nodes.FixedWithNextNode;
  38 import org.graalvm.compiler.nodes.FrameState;
  39 import org.graalvm.compiler.nodes.Invoke;
  40 import org.graalvm.compiler.nodes.InvokeWithExceptionNode;
  41 import org.graalvm.compiler.nodes.MergeNode;
  42 import org.graalvm.compiler.nodes.PhiNode;
  43 import org.graalvm.compiler.nodes.PiNode;
  44 import org.graalvm.compiler.nodes.StructuredGraph;
  45 import org.graalvm.compiler.nodes.ValueNode;
  46 import org.graalvm.compiler.nodes.ValuePhiNode;
  47 import org.graalvm.compiler.nodes.extended.LoadHubNode;
  48 import org.graalvm.compiler.nodes.java.ExceptionObjectNode;

 324     private EconomicSet<Node> inlineSingleMethod(StructuredGraph graph, StampProvider stampProvider, ConstantReflectionProvider constantReflection) {
 325         assert concretes.size() == 1 && inlineableElements.length == 1 && ptypes.size() > 1 && !shouldFallbackToInvoke() && notRecordedTypeProbability == 0;
 326 
 327         AbstractBeginNode calleeEntryNode = graph.add(new BeginNode());
 328 
 329         AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph);
 330         AbstractBeginNode[] successors = new AbstractBeginNode[]{calleeEntryNode, unknownTypeSux};
 331         createDispatchOnTypeBeforeInvoke(graph, successors, false, stampProvider, constantReflection);
 332 
 333         calleeEntryNode.setNext(invoke.asNode());
 334 
 335         return inline(invoke, methodAt(0), inlineableElementAt(0), false);
 336     }
 337 
 338     private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, AbstractBeginNode[] successors, boolean invokeIsOnlySuccessor, StampProvider stampProvider,
 339                     ConstantReflectionProvider constantReflection) {
 340         assert ptypes.size() >= 1;
 341         ValueNode nonNullReceiver = InliningUtil.nonNullReceiver(invoke);
 342         LoadHubNode hub = graph.unique(new LoadHubNode(stampProvider, nonNullReceiver));
 343 
 344         graph.getDebug().log("Type switch with %d types", concretes.size());
 345 
 346         ResolvedJavaType[] keys = new ResolvedJavaType[ptypes.size()];
 347         double[] keyProbabilities = new double[ptypes.size() + 1];
 348         int[] keySuccessors = new int[ptypes.size() + 1];
 349         double totalProbability = notRecordedTypeProbability;
 350         for (int i = 0; i < ptypes.size(); i++) {
 351             keys[i] = ptypes.get(i).getType();
 352             keyProbabilities[i] = ptypes.get(i).getProbability();
 353             totalProbability += keyProbabilities[i];
 354             keySuccessors[i] = invokeIsOnlySuccessor ? 0 : typesToConcretes.get(i);
 355             assert keySuccessors[i] < successors.length - 1 : "last successor is the unknownTypeSux";
 356         }
 357         keyProbabilities[keyProbabilities.length - 1] = notRecordedTypeProbability;
 358         keySuccessors[keySuccessors.length - 1] = successors.length - 1;
 359 
 360         // Normalize the probabilities.
 361         for (int i = 0; i < keyProbabilities.length; i++) {
 362             keyProbabilities[i] /= totalProbability;
 363         }
 364