Rebase of partial ia32 implementation of optimized try/catch (started by Kevin Millikin, continued …

src/hydrogen.cc

 // Copyright 2012 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 4722 matching lines @@
 }
 
 
 void HOptimizedGraphBuilder::VisitBlock(Block* stmt) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   if (stmt->scope() != NULL) {
     return Bailout("ScopedBlock");
   }
-  BreakAndContinueInfo break_info(stmt);
+  BreakAndContinueInfo break_info(stmt, 0);
   { BreakAndContinueScope push(&break_info, this);
     CHECK_BAILOUT(VisitStatements(stmt->statements()));
   }
   HBasicBlock* break_block = break_info.break_block();
   if (break_block != NULL) {
     if (current_block() != NULL) current_block()->Goto(break_block);
     break_block->SetJoinId(stmt->ExitId());
     set_current_block(break_block);
   }
 }
@@ skipping 47 matching lines @@
     } else {
       cond_false = NULL;
     }
 
     HBasicBlock* join = CreateJoin(cond_true, cond_false, stmt->IfId());
     set_current_block(join);
   }
 }
 
 
-HBasicBlock* HOptimizedGraphBuilder::BreakAndContinueScope::Get(
-    BreakableStatement* stmt,
-    BreakType type,
-    int* drop_extra) {
-  *drop_extra = 0;
+void HOptimizedGraphBuilder::BreakAndContinueScope::UnwindReturn() {
   BreakAndContinueScope* current = this;
-  while (current != NULL && current->info()->target() != stmt) {
-    *drop_extra += current->info()->drop_extra();
+  while (current != NULL) {
+    TryCatchStatement* try_catch =
+        current->info()->statement()->AsTryCatchStatement();
+    if (try_catch != NULL) {
+      HLeaveTry* leave = new(owner()->zone()) HLeaveTry;
+      owner()->AddInstruction(leave);
+      owner()->environment()->RemoveExceptionHandler();
+      owner()->AddSimulate(try_catch->TryExitId());
+    }
+    current = current->next();
+  }
+}
+
+
+void HOptimizedGraphBuilder::BreakAndContinueScope::Unwind(BreakableStatement* target,
+                                                           BreakType type) {
+  BreakAndContinueScope* current = this;
+  while (current != NULL && current->info()->statement() != target) {
+    TryCatchStatement* try_catch =
+        current->info()->statement()->AsTryCatchStatement();
+    if (try_catch != NULL) {
+      HLeaveTry* leave = new(owner()->zone()) HLeaveTry;
+      owner()->AddInstruction(leave);
+      owner()->environment()->RemoveExceptionHandler();
+      owner()->AddSimulate(try_catch->TryExitId());
+    }
+    owner()->Drop(current->info()->drop_extra());
     current = current->next();
   }
   ASSERT(current != NULL);  // Always found (unless stack is malformed).
 
   if (type == BREAK) {
-    *drop_extra += current->info()->drop_extra();
+    owner()->Drop(current->info()->drop_extra());
   }
 
   HBasicBlock* block = NULL;
   switch (type) {
     case BREAK:
       block = current->info()->break_block();
       if (block == NULL) {
         block = current->owner()->graph()->CreateBasicBlock();
         current->info()->set_break_block(block);
       }
       break;
 
     case CONTINUE:
       block = current->info()->continue_block();
       if (block == NULL) {
         block = current->owner()->graph()->CreateBasicBlock();
         current->info()->set_continue_block(block);
       }
       break;
   }
-
-  return block;
+  owner()->current_block()->Goto(block);
+  owner()->set_current_block(NULL);
 }
 
 
 void HOptimizedGraphBuilder::VisitContinueStatement(
     ContinueStatement* stmt) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
-  int drop_extra = 0;
-  HBasicBlock* continue_block = break_scope()->Get(
-      stmt->target(), BreakAndContinueScope::CONTINUE, &drop_extra);
-  Drop(drop_extra);
-  current_block()->Goto(continue_block);
-  set_current_block(NULL);
+  break_scope()->Unwind(stmt->target(), BreakAndContinueScope::CONTINUE);
 }
 
 
 void HOptimizedGraphBuilder::VisitBreakStatement(BreakStatement* stmt) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
-  int drop_extra = 0;
-  HBasicBlock* break_block = break_scope()->Get(
-      stmt->target(), BreakAndContinueScope::BREAK, &drop_extra);
-  Drop(drop_extra);
-  current_block()->Goto(break_block);
-  set_current_block(NULL);
+  break_scope()->Unwind(stmt->target(), BreakAndContinueScope::BREAK);
 }
 
 
 void HOptimizedGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   FunctionState* state = function_state();
   AstContext* context = call_context();
   if (context == NULL) {
     // Not an inlined return, so an actual one.
     CHECK_ALIVE(VisitForValue(stmt->expression()));
     HValue* result = environment()->Pop();
+    break_scope()->UnwindReturn();
     AddReturn(result);
   } else if (state->inlining_kind() == CONSTRUCT_CALL_RETURN) {
     // Return from an inlined construct call. In a test context the return value
     // will always evaluate to true, in a value context the return value needs
     // to be a JSObject.
     if (context->IsTest()) {
       TestContext* test = TestContext::cast(context);
       CHECK_ALIVE(VisitForEffect(stmt->expression()));
       current_block()->Goto(test->if_true(), state);
     } else if (context->IsEffect()) {
@@ skipping 149 matching lines @@
   if (not_string_block != NULL) {
     BailoutId join_id = !default_id.IsNone() ? default_id : stmt->ExitId();
     last_block = CreateJoin(last_block, not_string_block, join_id);
   }
 
   // 2. Loop over the clauses and the linked list of tests in lockstep,
   // translating the clause bodies.
   HBasicBlock* curr_test_block = first_test_block;
   HBasicBlock* fall_through_block = NULL;
 
-  BreakAndContinueInfo break_info(stmt);
+  BreakAndContinueInfo break_info(stmt, 0);
   { BreakAndContinueScope push(&break_info, this);
     for (int i = 0; i < clause_count; ++i) {
       CaseClause* clause = clauses->at(i);
 
       // Identify the block where normal (non-fall-through) control flow
       // goes to.
       HBasicBlock* normal_block = NULL;
       if (clause->is_default()) {
         if (last_block != NULL) {
           normal_block = last_block;
@@ skipping 124 matching lines @@
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   ASSERT(current_block() != NULL);
   bool osr_entry = PreProcessOsrEntry(stmt);
   HBasicBlock* loop_entry = CreateLoopHeaderBlock();
   current_block()->Goto(loop_entry);
   set_current_block(loop_entry);
   if (osr_entry) graph()->set_osr_loop_entry(loop_entry);
 
-  BreakAndContinueInfo break_info(stmt);
+  BreakAndContinueInfo break_info(stmt, 0);
   CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry, &break_info));
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
   HBasicBlock* loop_successor = NULL;
   if (body_exit != NULL && !stmt->cond()->ToBooleanIsTrue()) {
     set_current_block(body_exit);
     // The block for a true condition, the actual predecessor block of the
     // back edge.
     body_exit = graph()->CreateBasicBlock();
     loop_successor = graph()->CreateBasicBlock();
@@ skipping 40 matching lines @@
       body_entry->SetJoinId(stmt->BodyId());
       set_current_block(body_entry);
     }
     if (loop_successor->HasPredecessor()) {
       loop_successor->SetJoinId(stmt->ExitId());
     } else {
       loop_successor = NULL;
     }
   }
 
-  BreakAndContinueInfo break_info(stmt);
+  BreakAndContinueInfo break_info(stmt, 0);
   if (current_block() != NULL) {
     CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry, &break_info));
   }
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
   HBasicBlock* loop_exit = CreateLoop(stmt,
                                       loop_entry,
                                       body_exit,
                                       loop_successor,
                                       break_info.break_block());
@@ skipping 24 matching lines @@
       body_entry->SetJoinId(stmt->BodyId());
       set_current_block(body_entry);
     }
     if (loop_successor->HasPredecessor()) {
       loop_successor->SetJoinId(stmt->ExitId());
     } else {
       loop_successor = NULL;
     }
   }
 
-  BreakAndContinueInfo break_info(stmt);
+  BreakAndContinueInfo break_info(stmt, 0);
   if (current_block() != NULL) {
     CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry, &break_info));
   }
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
 
   if (stmt->next() != NULL && body_exit != NULL) {
     set_current_block(body_exit);
     CHECK_BAILOUT(Visit(stmt->next()));
     body_exit = current_block();
@@ skipping 134 matching lines @@
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   return Bailout("ForOfStatement");
 }
 
 
 void HOptimizedGraphBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
-  return Bailout("TryCatchStatement");
+  if (!FLAG_crankshaft_try_support) {
+    Bailout("try statement support disabled");
+    return;
+  }
+  HEnterTry* enter = new(zone()) HEnterTry(stmt->index());
+  AddInstruction(enter);
+  environment()->AddExceptionHandler();
+  AddSimulate(stmt->TryEntryId());
+  BreakAndContinueInfo try_info(stmt, 0);
+  { BreakAndContinueScope push(&try_info, this);
+    CHECK_BAILOUT(Visit(stmt->try_block()));
+  }
+  if (current_block() != NULL) {
+    HLeaveTry* leave = new(zone()) HLeaveTry;
+    AddInstruction(leave);
+    environment()->RemoveExceptionHandler();
+    AddSimulate(stmt->TryExitId());
+  }
 }
 
 
 void HOptimizedGraphBuilder::VisitTryFinallyStatement(
     TryFinallyStatement* stmt) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   return Bailout("TryFinallyStatement");
 }
@@ skipping 5436 matching lines @@
 HEnvironment::HEnvironment(HEnvironment* outer,
                            Scope* scope,
                            Handle<JSFunction> closure,
                            Zone* zone)
     : closure_(closure),
       values_(0, zone),
       frame_type_(JS_FUNCTION),
       parameter_count_(0),
       specials_count_(1),
       local_count_(0),
+      handler_count_(0),
       outer_(outer),
       entry_(NULL),
       pop_count_(0),
       push_count_(0),
       ast_id_(BailoutId::None()),
       zone_(zone) {
   Initialize(scope->num_parameters() + 1, scope->num_stack_slots(), 0);
 }
 
 
@@ skipping 12 matching lines @@
   Initialize(parameter_count, 0, 0);
 }
 
 
 HEnvironment::HEnvironment(const HEnvironment* other, Zone* zone)
     : values_(0, zone),
       frame_type_(JS_FUNCTION),
       parameter_count_(0),
       specials_count_(0),
       local_count_(0),
+      handler_count_(0),
       outer_(NULL),
       entry_(NULL),
       pop_count_(0),
       push_count_(0),
       ast_id_(other->ast_id()),
       zone_(zone) {
   Initialize(other);
 }
 
 
 HEnvironment::HEnvironment(HEnvironment* outer,
                            Handle<JSFunction> closure,
                            FrameType frame_type,
                            int arguments,
                            Zone* zone)
     : closure_(closure),
       values_(arguments, zone),
       frame_type_(frame_type),
       parameter_count_(arguments),
       specials_count_(0),
       local_count_(0),
+      handler_count_(0),
       outer_(outer),
       entry_(NULL),
       pop_count_(0),
       push_count_(0),
       ast_id_(BailoutId::None()),
       zone_(zone) {
 }
 
 
 void HEnvironment::Initialize(int parameter_count,
                               int local_count,
                               int stack_height) {
   parameter_count_ = parameter_count;
   local_count_ = local_count;
 
   // Avoid reallocating the temporaries' backing store on the first Push.
   int total = parameter_count + specials_count_ + local_count + stack_height;
   values_.Initialize(total + 4, zone());
   for (int i = 0; i < total; ++i) values_.Add(NULL, zone());
 }
 
 
 void HEnvironment::Initialize(const HEnvironment* other) {
   closure_ = other->closure();
   values_.AddAll(other->values_, zone());
   assigned_variables_.Union(other->assigned_variables_, zone());
   frame_type_ = other->frame_type_;
   parameter_count_ = other->parameter_count_;
   local_count_ = other->local_count_;
+  handler_count_ = other->handler_count_;
   if (other->outer_ != NULL) outer_ = other->outer_->Copy();  // Deep copy.
   entry_ = other->entry_;
   pop_count_ = other->pop_count_;
   push_count_ = other->push_count_;
   specials_count_ = other->specials_count_;
   ast_id_ = other->ast_id_;
 }
 
 
 void HEnvironment::AddIncomingEdge(HBasicBlock* block, HEnvironment* other) {
   ASSERT(!block->IsLoopHeader());
   ASSERT(values_.length() == other->values_.length());
+  ASSERT(handler_count_ == other->handler_count_);
 
   int length = values_.length();
   for (int i = 0; i < length; ++i) {
     HValue* value = values_[i];
     if (value != NULL && value->IsPhi() && value->block() == block) {
       // There is already a phi for the i'th value.
       HPhi* phi = HPhi::cast(value);
       // Assert index is correct and that we haven't missed an incoming edge.
       ASSERT(phi->merged_index() == i);
       ASSERT(phi->OperandCount() == block->predecessors()->length());
@@ skipping 548 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal