Allow breakpoints on strict equal

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 233 matching lines @@
     // by the constant propagation.
     TargetEntryInstr* false_block =
         new TargetEntryInstr(caller_graph_->allocate_block_id(),
                              call_block->try_index());
     false_block->InheritDeoptTargetAfter(call_);
     false_block->LinkTo(call_->next());
     call_block->ReplaceAsPredecessorWith(false_block);
 
     ConstantInstr* true_const = caller_graph_->GetConstant(Bool::True());
     BranchInstr* branch =
-        new BranchInstr(new StrictCompareInstr(Token::kEQ_STRICT,
+        new BranchInstr(new StrictCompareInstr(call_block->start_pos(),
+                                               Token::kEQ_STRICT,
                                                new Value(true_const),
                                                new Value(true_const)));
     branch->InheritDeoptTarget(call_);
     *branch->true_successor_address() = callee_entry;
     *branch->false_successor_address() = false_block;
 
     call_->previous()->AppendInstruction(branch);
     call_block->set_last_instruction(branch);
 
     // Update dominator tree.
@@ skipping 379 matching lines @@
   return CreateSuccessorFor(false_successor_addresses_);
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     value = Bind(new AssertBooleanInstr(condition_token_pos(), value));
   }
   Value* constant_true = Bind(new ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
-      new StrictCompareInstr(Token::kEQ_STRICT, value, constant_true);
+      new StrictCompareInstr(condition_token_pos(),
+                             Token::kEQ_STRICT,
+                             value,
+                             constant_true);
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
 
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithComparison(ComparisonInstr* comp) {
   ControlInstruction* branch;
   if (Token::IsStrictEqualityOperator(comp->kind())) {
-    branch = new BranchInstr(new StrictCompareInstr(comp->kind(),
+    branch = new BranchInstr(new StrictCompareInstr(comp->token_pos(),
+                                                    comp->kind(),
                                                     comp->left(),
                                                     comp->right()));
   } else if (Token::IsEqualityOperator(comp->kind()) &&
              (comp->left()->BindsToConstantNull() ||
               comp->right()->BindsToConstantNull())) {
     branch = new BranchInstr(new StrictCompareInstr(
+        comp->token_pos(),
         (comp->kind() == Token::kEQ) ? Token::kEQ_STRICT : Token::kNE_STRICT,
         comp->left(),
         comp->right()));
   } else {
     branch = new BranchInstr(comp, FLAG_enable_type_checks);
   }
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
   ASSERT(!FLAG_enable_type_checks);
   Value* constant_true = Bind(new ConstantInstr(Bool::True()));
   BranchInstr* branch = new BranchInstr(
-      new StrictCompareInstr(Token::kNE_STRICT, neg->value(), constant_true));
+      new StrictCompareInstr(condition_token_pos(),
+                             Token::kNE_STRICT,
+                             neg->value(),
+                             constant_true));
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::ReturnDefinition(Definition* definition) {
   ComparisonInstr* comp = definition->AsComparison();
   if (comp != NULL) {
@@ skipping 281 matching lines @@
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
                                                 right_value));
     }
     Value* constant_true = for_right.Bind(new ConstantInstr(Bool::True()));
     Value* compare =
-        for_right.Bind(new StrictCompareInstr(Token::kEQ_STRICT,
+        for_right.Bind(new StrictCompareInstr(node->token_pos(),
+                                              Token::kEQ_STRICT,
                                               right_value,
                                               constant_true));
     for_right.Do(BuildStoreExprTemp(compare));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
       Value* constant_false = for_false.Bind(new ConstantInstr(Bool::False()));
       for_false.Do(BuildStoreExprTemp(constant_false));
       Join(for_test, for_right, for_false);
     } else {
@@ skipping 289 matching lines @@
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
-    StrictCompareInstr* comp = new StrictCompareInstr(
-        node->kind(), for_left_value.value(), for_right_value.value());
+    StrictCompareInstr* comp = new StrictCompareInstr(node->token_pos(),
+                                                      node->kind(),
+                                                      for_left_value.value(),
+                                                      for_right_value.value());
     ReturnDefinition(comp);
     return;
   }
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
@@ skipping 2108 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart