Add Uint32AddWithOverflow and Uint32SubWithOverflow machine operators.

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 27 matching lines @@
     DPI sub = {machine.Int32Sub(), kArmSub, kArmRsb, kArmCmp};
     push_back(sub);
   }
 };
 
 
 struct ODPI {
   Operator* op;
   ArchOpcode arch_opcode;
   ArchOpcode reverse_arch_opcode;
+  FlagsCondition condition;
+  FlagsCondition negated_condition;
 };
 
 
 // ARM data processing instructions with overflow.
 class ODPIs V8_FINAL : public std::list<ODPI>, private HandleAndZoneScope {
  public:
   ODPIs() {
     MachineOperatorBuilder machine(main_zone());
-    ODPI add = {machine.Int32AddWithOverflow(), kArmAdd, kArmAdd};
-    push_back(add);
-    ODPI sub = {machine.Int32SubWithOverflow(), kArmSub, kArmRsb};
-    push_back(sub);
+    ODPI sadd = {machine.Int32AddWithOverflow(), kArmAdd, kArmAdd, kOverflow,
+                 kNotOverflow};
+    push_back(sadd);
+    ODPI ssub = {machine.Int32SubWithOverflow(), kArmSub, kArmRsb, kOverflow,
+                 kNotOverflow};
+    push_back(ssub);
+    ODPI uadd = {machine.Uint32AddWithOverflow(), kArmAdd, kArmAdd,
+                 kUnsignedGreaterThanOrEqual, kUnsignedLessThan};
+    push_back(uadd);
+    ODPI usub = {machine.Uint32SubWithOverflow(), kArmSub, kArmRsb,
+                 kUnsignedLessThan, kUnsignedGreaterThanOrEqual};
+    push_back(usub);
   }
 };
 
 
 // ARM immediates.
 class Immediates V8_FINAL : public std::list<int32_t> {
  public:
   Immediates() {
     for (uint32_t imm8 = 0; imm8 < 256; ++imm8) {
       for (uint32_t rot4 = 0; rot4 < 32; rot4 += 2) {
@@ skipping 210 matching lines @@
     ODPI odpi = *i;
     {
       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(odpi.condition, m.code[0]->flags_condition());
       CHECK_EQ(2, m.code[0]->InputCount());
       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_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());
-      CHECK_EQ(kOverflow, m.code[0]->flags_condition());
+      CHECK_EQ(odpi.condition, m.code[0]->flags_condition());
       CHECK_EQ(2, m.code[0]->InputCount());
       CHECK_EQ(2, m.code[0]->OutputCount());
     }
   }
 }
 
 
 TEST(InstructionSelectorODPIImm) {
   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;
         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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
         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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
         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());
@@ skipping 19 matching lines @@
       }
       {
         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());
-        CHECK_EQ(kOverflow, m.code[0]->flags_condition());
+        CHECK_EQ(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
         CHECK_EQ(2, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         Node* node = m.NewNode(odpi.op, m.Int32Constant(imm), m.Parameter(0));
         m.Return(m.Word32Equal(m.Projection(0, node), m.Projection(1, node)));
         m.SelectInstructions();
         CHECK_LE(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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
         CHECK_EQ(2, m.code[0]->OutputCount());
       }
     }
   }
 }
 
 
 TEST(InstructionSelectorODPIAndShiftP) {
   ODPIs odpis;
   Shifts shifts;
   for (ODPIs::const_iterator i = odpis.begin(); i != odpis.end(); ++i) {
     ODPI odpi = *i;
     for (Shifts::const_iterator j = shifts.begin(); j != shifts.end(); ++j) {
       Shift shift = *j;
       {
         InstructionSelectorTester m;
         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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(3, m.code[0]->InputCount());
         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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(3, m.code[0]->InputCount());
         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());
@@ skipping 21 matching lines @@
         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());
         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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(3, m.code[0]->InputCount());
         CHECK_EQ(2, m.code[0]->OutputCount());
       }
       {
         InstructionSelectorTester m;
         Node* node = m.NewNode(
             odpi.op, m.NewNode(shift.op, m.Parameter(0), 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.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(odpi.condition, m.code[0]->flags_condition());
         CHECK_EQ(3, m.code[0]->InputCount());
         CHECK_EQ(2, m.code[0]->OutputCount());
       }
     }
   }
 }
 
 
 TEST(InstructionSelectorODPIAndShiftImm) {
   ODPIs odpis;
   Shifts shifts;
   for (ODPIs::const_iterator i = odpis.begin(); i != odpis.end(); ++i) {
     ODPI odpi = *i;
     for (Shifts::const_iterator j = shifts.begin(); j != shifts.end(); ++j) {
       Shift shift = *j;
       for (int32_t imm = shift.i_low; imm <= shift.i_high; ++imm) {
         {
           InstructionSelectorTester m;
           m.Return(m.Projection(1, 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_set, m.code[0]->flags_mode());
-          CHECK_EQ(kOverflow, m.code[0]->flags_condition());
+          CHECK_EQ(odpi.condition, m.code[0]->flags_condition());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
           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(odpi.condition, m.code[0]->flags_condition());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
           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();
@@ skipping 24 matching lines @@
           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());
           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(odpi.condition, m.code[0]->flags_condition());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
           CHECK_EQ(2, m.code[0]->OutputCount());
         }
         {
           InstructionSelectorTester m;
           Node* node = m.NewNode(odpi.op, m.NewNode(shift.op, m.Parameter(0),
                                                     m.Int32Constant(imm)),
                                  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.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(odpi.condition, m.code[0]->flags_condition());
           CHECK_EQ(3, m.code[0]->InputCount());
           CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(2)));
           CHECK_EQ(2, m.code[0]->OutputCount());
         }
       }
     }
   }
 }
 
 
@@ skipping 1107 matching lines @@
       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());
+      CHECK_EQ(odpi.condition, 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());
+      CHECK_EQ(odpi.negated_condition, 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());
+      CHECK_EQ(odpi.negated_condition, 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_EQ(odpi.condition, 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_EQ(odpi.condition, 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_EQ(odpi.negated_condition, 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_EQ(odpi.negated_condition, m.code[0]->flags_condition());
         CHECK_LE(2, m.code[0]->InputCount());
         CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
       }
     }
   }
 }