Implement condition type checks in new compiler, thereby removing last bailouts.

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 142 matching lines @@
       new LoadLocalComp(variable, owner()->context_level());
   AddInstruction(new BindInstr(start_index, load_saved_context));
   StoreContextComp* store_context =
       new StoreContextComp(new TempVal(start_index));
   AddInstruction(new DoInstr(store_context));
 }
 
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
+  if (FLAG_enable_type_checks) {
+    AssertBooleanComp* assert_boolean =
+        new AssertBooleanComp(condition_node_id(),
+                              condition_token_index(),
+                              owner()->try_index(),
+                              value);
+    AddInstruction(new BindInstr(temp_index(), assert_boolean));
+    value = new TempVal(temp_index());
+  }
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void ArgumentGraphVisitor::ReturnValue(Value* value) {
   value_ = value;
@@ skipping 118 matching lines @@
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
-    TestGraphVisitor for_left(owner(), temp_index());
+    TestGraphVisitor for_left(owner(),
+                              temp_index(),
+                              node->left()->id(),
+                              node->left()->token_index());
     node->left()->Visit(&for_left);
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     EffectGraphVisitor empty(owner(), temp_index());
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
@@ skipping 24 matching lines @@
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
-    TestGraphVisitor for_test(owner(), temp_index());
+    TestGraphVisitor for_test(owner(),
+                              temp_index(),
+                              node->left()->id(),
+                              node->left()->token_index());
     node->left()->Visit(&for_test);
-    if (FLAG_enable_type_checks) {
-      Bailout("GenerateConditionTypeCheck in kAND/kOR");
-    }
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
+    Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
-      Bailout("GenerateConditionTypeCheck in kAND/kOR");
+      AssertBooleanComp* assert_boolean =
+          new AssertBooleanComp(node->right()->id(),
+                                node->right()->token_index(),
+                                owner()->try_index(),
+                                right_value);
+      for_right.AddInstruction(new BindInstr(temp_index(), assert_boolean));
+      right_value = new TempVal(temp_index());
     }
     StrictCompareComp* comp = new StrictCompareComp(Token::kEQ_STRICT,
-        for_right.value(), new ConstantVal(bool_true));
+        right_value, new ConstantVal(bool_true));
     for_right.AddInstruction(new BindInstr(temp_index(), comp));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
       for_false.AddInstruction(
           new BindInstr(temp_index(), new ConstantVal(bool_false)));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
@@ skipping 193 matching lines @@
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
         node->id(), node->token_index(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
       AddInstruction(new BindInstr(temp_index(), comp));
       Value* eq_result = new TempVal(temp_index());
+      if (FLAG_enable_type_checks) {
+        AssertBooleanComp* assert_boolean =
+            new AssertBooleanComp(node->id(),
+                                  node->token_index(),
+                                  owner()->try_index(),
+                                  eq_result);
+        AddInstruction(new BindInstr(temp_index(), assert_boolean));
+        eq_result = new TempVal(temp_index());
+      }
       BooleanNegateComp* negate = new BooleanNegateComp(eq_result);
       ReturnComputation(negate);
     }
     return;
   }
 
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(
       node->id(), node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 2);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
+    Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
-      Bailout("GenerateConditionTypeCheck in kNOT");
+      AssertBooleanComp* assert_boolean =
+          new AssertBooleanComp(node->operand()->id(),
+                                node->operand()->token_index(),
+                                owner()->try_index(),
+                                value);
+      AddInstruction(new BindInstr(temp_index(), assert_boolean));
+      value = new TempVal(temp_index());
     }
-    BooleanNegateComp* negate = new BooleanNegateComp(for_value.value());
+    BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ArgumentGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol((node->kind() == Token::kSUB)
@@ skipping 243 matching lines @@
   arguments->Add(new TempVal(value_index));
   InstanceCallComp* store = new InstanceCallComp(
       node->store_id(), node->token_index(), owner()->try_index(),
       store_name, arguments, Array::ZoneHandle(), 1);
   AddInstruction(new DoInstr(store));
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  TestGraphVisitor for_test(owner(), temp_index());
+  TestGraphVisitor for_test(owner(),
+                            temp_index(),
+                            node->condition()->id(),
+                            node->condition()->token_index());
   node->condition()->Visit(&for_test);
-  if (FLAG_enable_type_checks) {
-    Bailout("GenerateConditionTypeCheck in conditional expr");
-  }
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   EffectGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  TestGraphVisitor for_test(owner(), temp_index());
+  TestGraphVisitor for_test(owner(),
+                            temp_index(),
+                            node->condition()->id(),
+                            node->condition()->token_index());
   node->condition()->Visit(&for_test);
-  if (FLAG_enable_type_checks) {
-    Bailout("GenerateConditionTypeCheck in conditional expr");
-  }
 
   // Ensure that the value of the true/false subexpressions are named with
   // the same temporary name.
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   if (for_true.value()->IsTemp()) {
     ASSERT(for_true.value()->AsTemp()->index() == temp_index());
   } else {
     for_true.AddInstruction(new BindInstr(temp_index(), for_true.value()));
@@ skipping 10 matching lines @@
 
   Join(for_test, for_true, for_false);
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
-  TestGraphVisitor for_test(owner(), temp_index());
+  TestGraphVisitor for_test(owner(),
+                            temp_index(),
+                            node->condition()->id(),
+                            node->condition()->token_index());
   node->condition()->Visit(&for_test);
-  if (FLAG_enable_type_checks) {
-    Bailout("GenerateConditionTypeCheck in if");
-  }
 
   EffectGraphVisitor for_true(owner(), temp_index());
   EffectGraphVisitor for_false(owner(), temp_index());
 
   node->true_branch()->Visit(&for_true);
   // The for_false graph fragment will be empty (default graph fragment) if
   // we do not call Visit.
   if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   Join(for_test, for_true, for_false);
 }
@@ skipping 66 matching lines @@
     return;
   }
 
   // Generate instructions for all case expressions and collect data to
   // connect them.
   GrowableArray<TargetEntryInstr**> case_true_addresses;
   GrowableArray<TargetEntryInstr**> case_false_addresses;
   GrowableArray<TargetEntryInstr*> case_entries;
   for (intptr_t i = 0; i < len; i++) {
     AstNode* case_expr = node->case_expressions()->NodeAt(i);
-    TestGraphVisitor for_case_expression(owner(), temp_index());
+    TestGraphVisitor for_case_expression(owner(),
+                                         temp_index(),
+                                         case_expr->id(),
+                                         case_expr->token_index());
     if (i == 0) {
       case_entries.Add(NULL);  // Not to be used
       case_expr->Visit(&for_case_expression);
       // Append only the first one, everything else is connected from it.
       Append(for_case_expression);
     } else {
       TargetEntryInstr* case_entry_target = new TargetEntryInstr();
       case_entries.Add(case_entry_target);
       for_case_expression.AddInstruction(case_entry_target);
       case_expr->Visit(&for_case_expression);
@@ skipping 59 matching lines @@
 //                         body:      <Sequence> }
 // The fragment is composed as follows:
 // a) continue-join (optional)
 // b) loop-join
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ] -> (loop-join)
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
-  TestGraphVisitor for_test(owner(), temp_index());
+  TestGraphVisitor for_test(owner(),
+                            temp_index(),
+                            node->condition()->id(),
+                            node->condition()->token_index());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
-  if (FLAG_enable_type_checks) {
-    Bailout("GenerateConditionTypeCheck in while");
-  }
-
   EffectGraphVisitor for_body(owner(), temp_index());
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   if (lbl->join_for_continue() != NULL) {
     AddInstruction(lbl->join_for_continue());
   }
   TieLoop(for_test, for_body);
   if (lbl->join_for_break() != NULL) {
     AddInstruction(lbl->join_for_break());
   }
 }
 
 
 // The fragment is composed as follows:
 // a) body-entry-join
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   node->body()->Visit(&for_body);
 
-  TestGraphVisitor for_test(owner(), temp_index());
+  TestGraphVisitor for_test(owner(),
+                            temp_index(),
+                            node->condition()->id(),
+                            node->condition()->token_index());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
-  if (FLAG_enable_type_checks) {
-    Bailout("GenerateConditionTypeCheck in do while");
-  }
-
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join = new JoinEntryInstr();
   AddInstruction(body_entry_join);
   body_entry_join->SetSuccessor(for_body.entry());
   Instruction* body_exit =
       for_body.is_empty() ? body_entry_join : for_body.exit();
 
   if (for_body.is_open() || (node->label()->join_for_continue() != NULL)) {
     BlockEntryInstr* test_entry = NULL;
     if (node->label()->join_for_continue() == NULL) {
@@ skipping 82 matching lines @@
     // Endless loop, no test.
     Append(for_body);
     if (node->label()->join_for_break() == NULL) {
       CloseFragment();
     } else {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
     TargetEntryInstr* loop_exit = new TargetEntryInstr();
-    TestGraphVisitor for_test(owner(), temp_index());
+    TestGraphVisitor for_test(owner(),
+                              temp_index(),
+                              node->condition()->id(),
+                              node->condition()->token_index());
     node->condition()->Visit(&for_test);
     Append(for_test);
-    if (FLAG_enable_type_checks) {
-      Bailout("GenerateConditionTypeCheck in for");
-    }
     *for_test.true_successor_address() = body_entry;
     *for_test.false_successor_address() = loop_exit;
     if (node->label()->join_for_break() == NULL) {
       exit_ = loop_exit;
     } else {
       loop_exit->SetSuccessor(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
 }
@@ skipping 510 matching lines @@
 
   Value* value = for_value.value();
   if (FLAG_enable_type_checks) {
     Value* type_arguments = NULL;
     if (!node->local().type().IsInstantiated()) {
       type_arguments = BuildInstantiatorTypeArguments(
           node->token_index(), for_value.temp_index());
     }
     AssertAssignableComp* assert_assignable =
         new AssertAssignableComp(node->id(),
-                                 node->local().token_index(),
+                                 node->value()->token_index(),
                                  owner()->try_index(),
                                  value,
                                  type_arguments,
                                  node->local().type(),
                                  node->local().name());
     AddInstruction(new BindInstr(temp_index(), assert_assignable));
     value = new TempVal(temp_index());
   }
 
   StoreLocalComp* store =
@@ skipping 59 matching lines @@
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     Value* type_arguments = NULL;
     if (!type.IsInstantiated()) {
       type_arguments = BuildInstantiatorTypeArguments(
           node->token_index(), for_value.temp_index());
     }
     AssertAssignableComp* assert_assignable =
         new AssertAssignableComp(node->id(),
-                                 node->field().token_index(),
+                                 node->value()->token_index(),
                                  owner()->try_index(),
                                  store_value,
                                  type_arguments,
                                  type,
                                  String::ZoneHandle(node->field().name()));
     AddInstruction(new BindInstr(temp_index(), assert_assignable));
     store_value = new TempVal(temp_index());
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
@@ skipping 396 matching lines @@
 
 void FlowGraphPrinter::VisitConstant(ConstantVal* val) {
   OS::Print("#%s", val->value().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
   OS::Print("AssertAssignable(");
   comp->value()->Accept(this);
   OS::Print(", %s, '%s'",
-            comp->dst_type().ToCString(),
+            String::Handle(comp->dst_type().Name()).ToCString(),
             comp->dst_name().ToCString());
   if (comp->type_arguments() != NULL) {
     OS::Print(" (type-arg:");
     comp->type_arguments()->Accept(this);
   }
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitAssertBoolean(AssertBooleanComp* comp) {
@@ skipping 452 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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