[turbofan] Support for combining branches with <Operation>WithOverflow.

test/cctest/compiler/test-instruction-selector-arm.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <list>
 
 #include "test/cctest/compiler/instruction-selector-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::internal;
@@ skipping 242 matching lines @@
       InstructionSelectorTester m;
       m.Return(
           m.Projection(1, m.NewNode(odpi.op, m.Parameter(0), m.Parameter(1))));
       m.SelectInstructions();
       CHECK_EQ(1, m.code.size());
       CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
       CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
       CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
       CHECK_EQ(kOverflow, m.code[0]->flags_condition());
       CHECK_EQ(2, m.code[0]->InputCount());
-      CHECK_EQ(1, m.code[0]->OutputCount());
+      CHECK_LE(1, m.code[0]->OutputCount());
     }
     {
       InstructionSelectorTester m;
       m.Return(
           m.Projection(0, m.NewNode(odpi.op, m.Parameter(0), m.Parameter(1))));
       m.SelectInstructions();
       CHECK_EQ(1, m.code.size());
       CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
       CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
       CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
       CHECK_EQ(2, m.code[0]->InputCount());
-      CHECK_EQ(1, m.code[0]->OutputCount());
+      CHECK_LE(1, m.code[0]->OutputCount());
     }
     {
       InstructionSelectorTester m;
       Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Parameter(1));
       m.Return(m.Word32Equal(m.Projection(0, node), m.Projection(1, node)));
       m.SelectInstructions();
       CHECK_LE(1, m.code.size());
       CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
       CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
       CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
@@ skipping 18 matching lines @@
         m.Return(m.Projection(
             1, m.NewNode(odpi.op, m.Parameter(0), m.Int32Constant(imm))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
         CHECK_EQ(kOverflow, m.code[0]->flags_condition());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         m.Return(m.Projection(
             1, m.NewNode(odpi.op, m.Int32Constant(imm), m.Parameter(0))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
         CHECK_EQ(kOverflow, m.code[0]->flags_condition());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         m.Return(m.Projection(
             0, m.NewNode(odpi.op, m.Parameter(0), m.Int32Constant(imm))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         m.Return(m.Projection(
             0, m.NewNode(odpi.op, m.Int32Constant(imm), m.Parameter(0))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Int32Constant(imm));
         m.Return(m.Word32Equal(m.Projection(0, node), m.Projection(1, node)));
         m.SelectInstructions();
         CHECK_LE(1, m.code.size());
         CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
@@ skipping 33 matching lines @@
         m.Return(m.Projection(
             1, m.NewNode(odpi.op, m.Parameter(0),
                          m.NewNode(shift.op, m.Parameter(1), m.Parameter(2)))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(shift.r_mode, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
         CHECK_EQ(kOverflow, m.code[0]->flags_condition());
         CHECK_EQ(3, m.code[0]->InputCount());
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         m.Return(m.Projection(
             1, m.NewNode(odpi.op,
                          m.NewNode(shift.op, m.Parameter(0), m.Parameter(1)),
                          m.Parameter(2))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(shift.r_mode, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
         CHECK_EQ(kOverflow, m.code[0]->flags_condition());
         CHECK_EQ(3, m.code[0]->InputCount());
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         m.Return(m.Projection(
             0, m.NewNode(odpi.op, m.Parameter(0),
                          m.NewNode(shift.op, m.Parameter(1), m.Parameter(2)))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(shift.r_mode, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
         CHECK_EQ(3, m.code[0]->InputCount());
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         m.Return(m.Projection(
             0, m.NewNode(odpi.op,
                          m.NewNode(shift.op, m.Parameter(0), m.Parameter(1)),
                          m.Parameter(2))));
         m.SelectInstructions();
         CHECK_EQ(1, m.code.size());
         CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
         CHECK_EQ(shift.r_mode, m.code[0]->addressing_mode());
         CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
         CHECK_EQ(3, m.code[0]->InputCount());
-        CHECK_EQ(1, m.code[0]->OutputCount());
+        CHECK_LE(1, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         Node* node =
             m.NewNode(odpi.op, m.Parameter(0),
                       m.NewNode(shift.op, m.Parameter(1), m.Parameter(2)));
         m.Return(m.Word32Equal(m.Projection(0, node), m.Projection(1, node)));
         m.SelectInstructions();
         CHECK_LE(1, m.code.size());
         CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
@@ skipping 37 matching lines @@
                                              m.NewNode(shift.op, m.Parameter(1),
                                                        m.Int32Constant(imm)))));
           m.SelectInstructions();
           CHECK_EQ(1, m.code.size());
           CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
           CHECK_EQ(shift.i_mode, m.code[0]->addressing_mode());
           CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
           CHECK_EQ(kOverflow, m.code[0]->flags_condition());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
-          CHECK_EQ(1, m.code[0]->OutputCount());
+          CHECK_LE(1, m.code[0]->OutputCount());
         }
         {
           InstructionSelectorTester m;
           m.Return(m.Projection(
               1, m.NewNode(odpi.op, m.NewNode(shift.op, m.Parameter(0),
                                               m.Int32Constant(imm)),
                            m.Parameter(1))));
           m.SelectInstructions();
           CHECK_EQ(1, m.code.size());
           CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
           CHECK_EQ(shift.i_mode, m.code[0]->addressing_mode());
           CHECK_EQ(kFlags_set, m.code[0]->flags_mode());
           CHECK_EQ(kOverflow, m.code[0]->flags_condition());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
-          CHECK_EQ(1, m.code[0]->OutputCount());
+          CHECK_LE(1, m.code[0]->OutputCount());
         }
         {
           InstructionSelectorTester m;
           m.Return(m.Projection(0, m.NewNode(odpi.op, m.Parameter(0),
                                              m.NewNode(shift.op, m.Parameter(1),
                                                        m.Int32Constant(imm)))));
           m.SelectInstructions();
           CHECK_EQ(1, m.code.size());
           CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
           CHECK_EQ(shift.i_mode, m.code[0]->addressing_mode());
           CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
-          CHECK_EQ(1, m.code[0]->OutputCount());
+          CHECK_LE(1, m.code[0]->OutputCount());
         }
         {
           InstructionSelectorTester m;
           m.Return(m.Projection(
               0, m.NewNode(odpi.op, m.NewNode(shift.op, m.Parameter(0),
                                               m.Int32Constant(imm)),
                            m.Parameter(1))));
           m.SelectInstructions();
           CHECK_EQ(1, m.code.size());
           CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
           CHECK_EQ(shift.i_mode, m.code[0]->addressing_mode());
           CHECK_EQ(kFlags_none, m.code[0]->flags_mode());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
-          CHECK_EQ(1, m.code[0]->OutputCount());
+          CHECK_LE(1, m.code[0]->OutputCount());
         }
         {
           InstructionSelectorTester m;
           Node* node = m.NewNode(
               odpi.op, m.Parameter(0),
               m.NewNode(shift.op, m.Parameter(1), m.Int32Constant(imm)));
           m.Return(m.Word32Equal(m.Projection(0, node), m.Projection(1, node)));
           m.SelectInstructions();
           CHECK_LE(1, m.code.size());
           CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
@@ skipping 1182 matching lines @@
       m.Return(m.Int32Constant(0));
       m.SelectInstructions();
       CHECK_EQ(1, m.code.size());
       CHECK_EQ(dpi.test_arch_opcode, m.code[0]->arch_opcode());
       CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
       CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
       CHECK_EQ(kEqual, m.code[0]->flags_condition());
     }
   }
 }
+
+
+TEST(InstructionSelectorBranchWithODPIP) {
+  ODPIs odpis;
+  for (ODPIs::const_iterator i = odpis.begin(); i != odpis.end(); ++i) {
+    ODPI odpi = *i;
+    {
+      InstructionSelectorTester m;
+      MLabel blocka, blockb;
+      Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Parameter(1));
+      m.Branch(m.Projection(1, node), &blocka, &blockb);
+      m.Bind(&blocka);
+      m.Return(m.Int32Constant(0));
+      m.Bind(&blockb);
+      m.Return(m.Projection(0, node));
+      m.SelectInstructions();
+      CHECK_EQ(1, m.code.size());
+      CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
+      CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
+      CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+      CHECK_EQ(kOverflow, m.code[0]->flags_condition());
+    }
+    {
+      InstructionSelectorTester m;
+      MLabel blocka, blockb;
+      Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Parameter(1));
+      m.Branch(m.Word32Equal(m.Projection(1, node), m.Int32Constant(0)),
+               &blocka, &blockb);
+      m.Bind(&blocka);
+      m.Return(m.Int32Constant(0));
+      m.Bind(&blockb);
+      m.Return(m.Projection(0, node));
+      m.SelectInstructions();
+      CHECK_EQ(1, m.code.size());
+      CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
+      CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
+      CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+      CHECK_EQ(kNotOverflow, m.code[0]->flags_condition());
+    }
+    {
+      InstructionSelectorTester m;
+      MLabel blocka, blockb;
+      Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Parameter(1));
+      m.Branch(m.Word32Equal(m.Int32Constant(0), m.Projection(1, node)),
+               &blocka, &blockb);
+      m.Bind(&blocka);
+      m.Return(m.Int32Constant(0));
+      m.Bind(&blockb);
+      m.Return(m.Projection(0, node));
+      m.SelectInstructions();
+      CHECK_EQ(1, m.code.size());
+      CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
+      CHECK_EQ(kMode_Operand2_R, m.code[0]->addressing_mode());
+      CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+      CHECK_EQ(kNotOverflow, m.code[0]->flags_condition());
+    }
+  }
+}
+
+
+TEST(InstructionSelectorBranchWithODPIImm) {
+  ODPIs odpis;
+  Immediates immediates;
+  for (ODPIs::const_iterator i = odpis.begin(); i != odpis.end(); ++i) {
+    ODPI odpi = *i;
+    for (Immediates::const_iterator j = immediates.begin();
+         j != immediates.end(); ++j) {
+      int32_t imm = *j;
+      {
+        InstructionSelectorTester m;
+        MLabel blocka, blockb;
+        Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Int32Constant(imm));
+        m.Branch(m.Projection(1, node), &blocka, &blockb);
+        m.Bind(&blocka);
+        m.Return(m.Int32Constant(0));
+        m.Bind(&blockb);
+        m.Return(m.Projection(0, node));
+        m.SelectInstructions();
+        CHECK_EQ(1, m.code.size());
+        CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
+        CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
+        CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+        CHECK_EQ(kOverflow, m.code[0]->flags_condition());
+        CHECK_LE(2, m.code[0]->InputCount());
+        CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
+      }
+      {
+        InstructionSelectorTester m;
+        MLabel blocka, blockb;
+        Node* node = m.NewNode(odpi.op, m.Int32Constant(imm), m.Parameter(0));
+        m.Branch(m.Projection(1, node), &blocka, &blockb);
+        m.Bind(&blocka);
+        m.Return(m.Int32Constant(0));
+        m.Bind(&blockb);
+        m.Return(m.Projection(0, node));
+        m.SelectInstructions();
+        CHECK_EQ(1, m.code.size());
+        CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
+        CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
+        CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+        CHECK_EQ(kOverflow, m.code[0]->flags_condition());
+        CHECK_LE(2, m.code[0]->InputCount());
+        CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
+      }
+      {
+        InstructionSelectorTester m;
+        MLabel blocka, blockb;
+        Node* node = m.NewNode(odpi.op, m.Parameter(0), m.Int32Constant(imm));
+        m.Branch(m.Word32Equal(m.Projection(1, node), m.Int32Constant(0)),
+                 &blocka, &blockb);
+        m.Bind(&blocka);
+        m.Return(m.Int32Constant(0));
+        m.Bind(&blockb);
+        m.Return(m.Projection(0, node));
+        m.SelectInstructions();
+        CHECK_EQ(1, m.code.size());
+        CHECK_EQ(odpi.arch_opcode, m.code[0]->arch_opcode());
+        CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
+        CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+        CHECK_EQ(kNotOverflow, m.code[0]->flags_condition());
+        CHECK_LE(2, m.code[0]->InputCount());
+        CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
+      }
+      {
+        InstructionSelectorTester m;
+        MLabel blocka, blockb;
+        Node* node = m.NewNode(odpi.op, m.Int32Constant(imm), m.Parameter(0));
+        m.Branch(m.Word32Equal(m.Projection(1, node), m.Int32Constant(0)),
+                 &blocka, &blockb);
+        m.Bind(&blocka);
+        m.Return(m.Int32Constant(0));
+        m.Bind(&blockb);
+        m.Return(m.Projection(0, node));
+        m.SelectInstructions();
+        CHECK_EQ(1, m.code.size());
+        CHECK_EQ(odpi.reverse_arch_opcode, m.code[0]->arch_opcode());
+        CHECK_EQ(kMode_Operand2_I, m.code[0]->addressing_mode());
+        CHECK_EQ(kFlags_branch, m.code[0]->flags_mode());
+        CHECK_EQ(kNotOverflow, m.code[0]->flags_condition());
+        CHECK_LE(2, m.code[0]->InputCount());
+        CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
+      }
+    }
+  }
+}