Added LongJump for bailout. When trying to fix all crashes, CHECK_ALIVE did not scale well as bail…

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/flags.h"
 #include "vm/intermediate_language.h"
+#include "vm/longjump.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from graph builder.");
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DECLARE_FLAG(bool, enable_type_checks);
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
     entry_ = other_fragment.entry();
     exit_ = other_fragment.exit();
   } else {
@@ skipping 91 matching lines @@
 void TestGraphVisitor::BranchOnValue(Value* value) {
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
-  if (FLAG_trace_bailout) {
-    OS::Print("Flow Graph Bailout: %s\n", reason);
-  }
   owner()->Bailout(reason);
 }
 
 
 // 'bailout' is a statement (without a semicolon), typically a return.
 #define CHECK_ALIVE(bailout)                            \
   do {                                                  \
-    if (owner()->HasBailedOut() || !is_open()) {        \
+    if (!is_open()) {                                   \
       bailout;                                          \
     }                                                   \
   } while (false)
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
@@ skipping 83 matching lines @@
   CHECK_ALIVE(return);
   BranchOnValueOf(assert);
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 InstanceCallComp* EffectGraphVisitor::TranslateBinaryOp(
     const BinaryOpNode& node) {
+  // Operators "&&" and "||" cannot be overloaded therefore do not call
+  // operator.
   if ((node.kind() == Token::kAND) || (node.kind() == Token::kOR)) {
-    Bailout("EffectGraphVisitor::VisitBinaryOpNode");
-    return NULL;
+    Bailout("EffectGraphVisitor::VisitBinaryOpNode AND/OR");
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node.left()->Visit(&for_left_value);
   Append(for_left_value);
   CHECK_ALIVE(return NULL);
   ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node.right()->Visit(&for_right_value);
   Append(for_right_value);
   CHECK_ALIVE(return NULL);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
@@ skipping 68 matching lines @@
   ReturnValueOf(call);
 }
 
 void TestGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   InstanceCallComp* call = TranslateComparison(*node);
   CHECK_ALIVE(return);
   BranchOnValueOf(call);
 }
 
 
+
+InstanceCallComp* EffectGraphVisitor::TranslateUnaryOp(
+    const UnaryOpNode& node) {
+  // "!" cannot be overloaded, therefore do not call operator.
+  if (node.kind() == Token::kNOT) {
+    Bailout("EffectGraphVisitor::VisitUnaryOpNode NOT");
+  }
+  ValueGraphVisitor for_value(owner(), temp_index());
+  node.operand()->Visit(&for_value);
+  Append(for_value);
+  ZoneGrowableArray<Value*>* argument = new ZoneGrowableArray<Value*>(1);
+  argument->Add(for_value.value());
+  return new InstanceCallComp(node.Name(), argument);
+}
+
+
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  Bailout("EffectGraphVisitor::VisitUnaryOpNode");
+  InstanceCallComp* call = TranslateUnaryOp(*node);
+  DoComputation(call);
 }
 void ValueGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  Bailout("ValueGraphVisitor::VisitUnaryOpNode");
+  InstanceCallComp* call = TranslateUnaryOp(*node);
+  ReturnValueOf(call);
 }
 void TestGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
-  Bailout("TestGraphVisitor::VisitUnaryOpNode");
+  InstanceCallComp* call = TranslateUnaryOp(*node);
+  BranchOnValueOf(call);
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpLocalNode");
 }
 void ValueGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   Bailout("ValueGraphVisitor::VisitIncrOpLocalNode");
 }
 void TestGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
@@ skipping 500 matching lines @@
   Bailout("EffectGraphVisitor::VisitInlinedFinallyNode");
 }
 void ValueGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   Bailout("ValueGraphVisitor::VisitInlinedFinallyNode");
 }
 void TestGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   Bailout("TestGraphVisitor::VisitInlinedFinallyNode");
 }
 
 
-void FlowGraphBuilder::TraceBailout() const {
-  if (FLAG_trace_bailout && HasBailedOut()) {
-    OS::Print("Failed: %s in %s\n",
-              bailout_reason_,
-              parsed_function().function().ToFullyQualifiedCString());
-  }
-}
-
-
 void FlowGraphBuilder::PrintGraph() const {
-  if (!FLAG_print_flow_graph || HasBailedOut()) return;
-
   OS::Print("==== %s\n",
             parsed_function().function().ToFullyQualifiedCString());
 
   for (intptr_t i = postorder_block_entries_.length() - 1; i >= 0; --i) {
     // Print the block entry.
     Instruction* current = postorder_block_entries_[i]->Print();
     // And all the successors until an exit, branch, or a block entry.
     while ((current != NULL) && !current->IsBlockEntry()) {
       OS::Print("\n");
       current = current->Print();
     }
     if (current != NULL && current->IsBlockEntry()) {
       OS::Print(" goto %d", current->GetBlockNumber());
     }
     OS::Print("\n");
   }
 }
 
 
 void FlowGraphBuilder::BuildGraph() {
   EffectGraphVisitor for_effect(this, 0);
   for_effect.AddInstruction(new TargetEntryInstr());
   parsed_function().node_sequence()->Visit(&for_effect);
-  TraceBailout();
-  if (!HasBailedOut() && (for_effect.entry() != NULL)) {
+  if (for_effect.entry() != NULL) {
     // Accumulate basic block entries via postorder traversal.
     for_effect.entry()->Postorder(&postorder_block_entries_);
     // Number the blocks in reverse postorder starting with 0.
     intptr_t last_index = postorder_block_entries_.length() - 1;
     for (intptr_t i = last_index; i >= 0; --i) {
       postorder_block_entries_[i]->SetBlockNumber(last_index - i);
     }
   }
-  PrintGraph();
+  if (FLAG_print_flow_graph) {
+    PrintGraph();
+  }
 }
 
+
+void FlowGraphBuilder::Bailout(const char* reason) {
+  const char* kFormat = "FlowGraphBuilder Bailout: %s";
+  intptr_t len = OS::SNPrint(NULL, 0, kFormat, reason) + 1;
+  char* chars = reinterpret_cast<char*>(
+      Isolate::Current()->current_zone()->Allocate(len));
+  OS::SNPrint(chars, len, kFormat, reason);
+  const Error& error = Error::Handle(
+      LanguageError::New(String::Handle(String::New(chars))));
+  Isolate::Current()->long_jump_base()->Jump(1, error);
+}
+
+
 }  // namespace dart