src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.loop/src/org/graalvm/compiler/loop/LoopFragmentInside.java
changeset 58533 46b0b7fe255c
parent 58299 6df94ce3ab2f
child 58679 9c3209ff7550
child 58877 aec7bf35d6f5
equal deleted inserted replaced
58532:b4f2e13d20ea 58533:46b0b7fe255c
     1 /*
     1 /*
     2  * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     5  * This code is free software; you can redistribute it and/or modify it
     6  * under the terms of the GNU General Public License version 2 only, as
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.
     7  * published by the Free Software Foundation.
   243         CountedLoopInfo mainCounted = loop.counted();
   243         CountedLoopInfo mainCounted = loop.counted();
   244         LoopBeginNode mainLoopBegin = loop.loopBegin();
   244         LoopBeginNode mainLoopBegin = loop.loopBegin();
   245         // Discard the segment entry and its flow, after if merging it into the loop
   245         // Discard the segment entry and its flow, after if merging it into the loop
   246         StructuredGraph graph = mainLoopBegin.graph();
   246         StructuredGraph graph = mainLoopBegin.graph();
   247         IfNode loopTest = mainCounted.getLimitTest();
   247         IfNode loopTest = mainCounted.getLimitTest();
   248         IfNode newSegmentTest = getDuplicatedNode(loopTest);
   248         IfNode newSegmentLoopTest = getDuplicatedNode(loopTest);
   249         AbstractBeginNode trueSuccessor = loopTest.trueSuccessor();
   249 
   250         AbstractBeginNode falseSuccessor = loopTest.falseSuccessor();
   250         // Redirect anchors
   251         FixedNode firstNode;
   251         AbstractBeginNode falseSuccessor = newSegmentLoopTest.falseSuccessor();
   252         boolean codeInTrueSide = false;
       
   253         if (trueSuccessor == mainCounted.getBody()) {
       
   254             firstNode = trueSuccessor.next();
       
   255             codeInTrueSide = true;
       
   256         } else {
       
   257             assert (falseSuccessor == mainCounted.getBody());
       
   258             firstNode = falseSuccessor.next();
       
   259         }
       
   260         trueSuccessor = newSegmentTest.trueSuccessor();
       
   261         falseSuccessor = newSegmentTest.falseSuccessor();
       
   262         for (Node usage : falseSuccessor.anchored().snapshot()) {
   252         for (Node usage : falseSuccessor.anchored().snapshot()) {
   263             usage.replaceFirstInput(falseSuccessor, loopTest.falseSuccessor());
   253             usage.replaceFirstInput(falseSuccessor, loopTest.falseSuccessor());
   264         }
   254         }
       
   255         AbstractBeginNode trueSuccessor = newSegmentLoopTest.trueSuccessor();
   265         for (Node usage : trueSuccessor.anchored().snapshot()) {
   256         for (Node usage : trueSuccessor.anchored().snapshot()) {
   266             usage.replaceFirstInput(trueSuccessor, loopTest.trueSuccessor());
   257             usage.replaceFirstInput(trueSuccessor, loopTest.trueSuccessor());
   267         }
   258         }
   268         AbstractBeginNode startBlockNode;
   259 
   269         if (codeInTrueSide) {
   260         // remove if test
   270             startBlockNode = trueSuccessor;
   261         graph.removeSplitPropagate(newSegmentLoopTest, loopTest.trueSuccessor() == mainCounted.getBody() ? trueSuccessor : falseSuccessor);
   271         } else {
   262 
   272             graph.getDebug().dump(DebugContext.VERBOSE_LEVEL, mainLoopBegin.graph(), "before");
   263         graph.getDebug().dump(DebugContext.DETAILED_LEVEL, graph, "Before placing segment");
   273             startBlockNode = falseSuccessor;
   264         if (mainCounted.getBody().next() instanceof LoopEndNode) {
   274         }
       
   275         FixedNode lastNode = getBlockEnd(startBlockNode);
       
   276         LoopEndNode loopEndNode = mainLoopBegin.getSingleLoopEnd();
       
   277         FixedWithNextNode lastCodeNode = (FixedWithNextNode) loopEndNode.predecessor();
       
   278         FixedNode newSegmentFirstNode = getDuplicatedNode(firstNode);
       
   279         FixedWithNextNode newSegmentLastNode = getDuplicatedNode(lastCodeNode);
       
   280         graph.getDebug().dump(DebugContext.DETAILED_LEVEL, loopEndNode.graph(), "Before placing segment");
       
   281         if (firstNode instanceof LoopEndNode) {
       
   282             GraphUtil.killCFG(getDuplicatedNode(mainLoopBegin));
   265             GraphUtil.killCFG(getDuplicatedNode(mainLoopBegin));
   283         } else {
   266         } else {
   284             newSegmentLastNode.clearSuccessors();
   267             AbstractBeginNode newSegmentBegin = getDuplicatedNode(mainLoopBegin);
   285             startBlockNode.setNext(lastNode);
   268             FixedNode newSegmentFirstNode = newSegmentBegin.next();
       
   269             EndNode newSegmentEnd = getBlockEnd(newSegmentBegin);
       
   270             FixedWithNextNode newSegmentLastNode = (FixedWithNextNode) newSegmentEnd.predecessor();
       
   271             LoopEndNode loopEndNode = mainLoopBegin.getSingleLoopEnd();
       
   272             FixedWithNextNode lastCodeNode = (FixedWithNextNode) loopEndNode.predecessor();
       
   273 
       
   274             newSegmentBegin.clearSuccessors();
   286             lastCodeNode.replaceFirstSuccessor(loopEndNode, newSegmentFirstNode);
   275             lastCodeNode.replaceFirstSuccessor(loopEndNode, newSegmentFirstNode);
   287             newSegmentLastNode.replaceFirstSuccessor(lastNode, loopEndNode);
   276             newSegmentLastNode.replaceFirstSuccessor(newSegmentEnd, loopEndNode);
   288             lastCodeNode.setNext(newSegmentFirstNode);
   277 
   289             newSegmentLastNode.setNext(loopEndNode);
   278             newSegmentBegin.safeDelete();
   290             startBlockNode.clearSuccessors();
   279             newSegmentEnd.safeDelete();
   291             lastNode.safeDelete();
   280         }
   292             Node newSegmentTestStart = newSegmentTest.predecessor();
   281         graph.getDebug().dump(DebugContext.DETAILED_LEVEL, graph, "After placing segment");
   293             LogicNode newSegmentIfTest = newSegmentTest.condition();
       
   294             newSegmentTestStart.clearSuccessors();
       
   295             newSegmentTest.safeDelete();
       
   296             newSegmentIfTest.safeDelete();
       
   297             trueSuccessor.safeDelete();
       
   298             falseSuccessor.safeDelete();
       
   299             newSegmentTestStart.safeDelete();
       
   300         }
       
   301         graph.getDebug().dump(DebugContext.DETAILED_LEVEL, loopEndNode.graph(), "After placing segment");
       
   302     }
   282     }
   303 
   283 
   304     private static EndNode getBlockEnd(FixedNode node) {
   284     private static EndNode getBlockEnd(FixedNode node) {
   305         FixedNode curNode = node;
   285         FixedNode curNode = node;
   306         while (curNode instanceof FixedWithNextNode) {
   286         while (curNode instanceof FixedWithNextNode) {