Refactoring and cleanup of control instructions

src/hydrogen-range-analysis.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 31 matching lines @@
 
 
 void HRangeAnalysisPhase::Analyze(HBasicBlock* block) {
   TraceRange("Analyzing block B%d\n", block->block_id());
 
   int last_changed_range = changed_ranges_.length() - 1;
 
   // Infer range based on control flow.
   if (block->predecessors()->length() == 1) {
     HBasicBlock* pred = block->predecessors()->first();
-    if (pred->end()->IsCompareIDAndBranch()) {
-      InferControlFlowRange(HCompareIDAndBranch::cast(pred->end()), block);
+    if (pred->end()->IsCompareNumericAndBranch()) {
+      InferControlFlowRange(HCompareNumericAndBranch::cast(pred->end()),
+                            block);
     }
   }
 
   // Process phi instructions.
   for (int i = 0; i < block->phis()->length(); ++i) {
     HPhi* phi = block->phis()->at(i);
     InferRange(phi);
   }
 
   // Go through all instructions of the current block.
   for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
     InferRange(it.Current());
   }
 
   // Continue analysis in all dominated blocks.
   for (int i = 0; i < block->dominated_blocks()->length(); ++i) {
     Analyze(block->dominated_blocks()->at(i));
   }
 
   RollBackTo(last_changed_range);
 }
 
 
-void HRangeAnalysisPhase::InferControlFlowRange(HCompareIDAndBranch* test,
+void HRangeAnalysisPhase::InferControlFlowRange(HCompareNumericAndBranch* test,
                                                 HBasicBlock* dest) {
   ASSERT((test->FirstSuccessor() == dest) == (test->SecondSuccessor() != dest));
   if (test->representation().IsSmiOrInteger32()) {
     Token::Value op = test->token();
     if (test->SecondSuccessor() == dest) {
       op = Token::NegateCompareOp(op);
     }
     Token::Value inverted_op = Token::ReverseCompareOp(op);
     UpdateControlFlowRange(op, test->left(), test->right());
     UpdateControlFlowRange(inverted_op, test->right(), test->left());
@@ skipping 72 matching lines @@
                original_range->lower(),
                original_range->upper());
   }
   TraceRange("New information was [%d,%d]\n",
              range->lower(),
              range->upper());
 }
 
 
 } }  // namespace v8::internal