CpuProfiler: do not calculate positions if it is not necessary (BuildCompareInstruction part).

src/hydrogen.cc

 // Copyright 2013 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 "src/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 4800 matching lines @@
 
     // Generate a compare and branch.
     CHECK_ALIVE(VisitForValue(clause->label()));
     HValue* label_value = Pop();
 
     Type* label_type = clause->label()->bounds().lower;
     Type* combined_type = clause->compare_type();
     HControlInstruction* compare = BuildCompareInstruction(
         Token::EQ_STRICT, tag_value, label_value, tag_type, label_type,
         combined_type,
-        ScriptPositionToSourcePosition(stmt->tag()->position()),
-        ScriptPositionToSourcePosition(clause->label()->position()),
         PUSH_BEFORE_SIMULATE, clause->id());
 
+    if (FLAG_hydrogen_track_positions) {
+      compare->SetOperandPositions(
+          zone(), ScriptPositionToSourcePosition(stmt->tag()->position()),
+          ScriptPositionToSourcePosition(clause->label()->position()));
+    }
     HBasicBlock* next_test_block = graph()->CreateBasicBlock();
     HBasicBlock* body_block = graph()->CreateBasicBlock();
     body_blocks.Add(body_block, zone());
     compare->SetSuccessorAt(0, body_block);
     compare->SetSuccessorAt(1, next_test_block);
     FinishCurrentBlock(compare);
 
     set_current_block(body_block);
     Drop(1);  // tag_value
 
@@ skipping 6081 matching lines @@
     // even though we are certain to pass the correct number of arguments here.
     HInstruction* result = New<HInvokeFunction>(function, 2);
     return ast_context()->ReturnInstruction(result, expr->id());
   }
 
   PushBeforeSimulateBehavior push_behavior =
     ast_context()->IsEffect() ? NO_PUSH_BEFORE_SIMULATE
                               : PUSH_BEFORE_SIMULATE;
   HControlInstruction* compare = BuildCompareInstruction(
       op, left, right, left_type, right_type, combined_type,
-      ScriptPositionToSourcePosition(expr->left()->position()),
-      ScriptPositionToSourcePosition(expr->right()->position()),
       push_behavior, expr->id());
   if (compare == NULL) return;  // Bailed out.
+  if (FLAG_hydrogen_track_positions) {
+    compare->SetOperandPositions(
+        zone(), ScriptPositionToSourcePosition(expr->left()->position()),
+        ScriptPositionToSourcePosition(expr->right()->position()));
+  }
   return ast_context()->ReturnControl(compare, expr->id());
 }
 
 
 HControlInstruction* HOptimizedGraphBuilder::BuildCompareInstruction(
     Token::Value op, HValue* left, HValue* right, Type* left_type,
-    Type* right_type, Type* combined_type, SourcePosition left_position,
-    SourcePosition right_position, PushBeforeSimulateBehavior push_sim_result,
-    BailoutId bailout_id) {
+    Type* right_type, Type* combined_type,
+    PushBeforeSimulateBehavior push_sim_result, BailoutId bailout_id) {
   // Cases handled below depend on collected type feedback. They should
   // soft deoptimize when there is no type feedback.
   if (!combined_type->IsInhabited()) {
     Add<HDeoptimize>(
         Deoptimizer::kInsufficientTypeFeedbackForCombinedTypeOfBinaryOperation,
         Deoptimizer::SOFT);
     combined_type = left_type = right_type = Type::Any(zone());
   }
 
   Representation left_rep = Representation::FromType(left_type);
@@ skipping 14 matching lines @@
         return New<HBranch>(graph()->GetConstantTrue());
       }
       // Can we get away with map check and not instance type check?
       HValue* operand_to_check =
           left->block()->block_id() < right->block()->block_id() ? left : right;
       if (combined_type->IsClass()) {
         Handle<Map> map = combined_type->AsClass()->Map();
         AddCheckMap(operand_to_check, map);
         HCompareObjectEqAndBranch* result =
             New<HCompareObjectEqAndBranch>(left, right);
-        if (FLAG_hydrogen_track_positions) {
-          result->set_operand_position(zone(), 0, left_position);
-          result->set_operand_position(zone(), 1, right_position);
-        }
         return result;
       } else {
         BuildCheckHeapObject(operand_to_check);
         Add<HCheckInstanceType>(operand_to_check,
                                 HCheckInstanceType::IS_SPEC_OBJECT);
         HCompareObjectEqAndBranch* result =
             New<HCompareObjectEqAndBranch>(left, right);
         return result;
       }
     } else {
@@ skipping 42 matching lines @@
           AddSimulate(bailout_id, REMOVABLE_SIMULATE);
         }
       }
       // TODO(jkummerow): Can we make this more efficient?
       HBranch* branch = New<HBranch>(result);
       return branch;
     } else {
       HCompareNumericAndBranch* result =
           New<HCompareNumericAndBranch>(left, right, op);
       result->set_observed_input_representation(left_rep, right_rep);
-      if (FLAG_hydrogen_track_positions) {
-        result->SetOperandPositions(zone(), left_position, right_position);
-      }
       return result;
     }
   }
 }
 
 
 void HOptimizedGraphBuilder::HandleLiteralCompareNil(CompareOperation* expr,
                                                      Expression* sub_expr,
                                                      NilValue nil) {
   DCHECK(!HasStackOverflow());
@@ skipping 2387 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal