Experimental: add a has_valid_frame predicate to the code generator...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 74 matching lines @@
       state_(NULL),
       is_inside_try_(false),
       break_stack_height_(0),
       loop_nesting_(0),
       function_return_is_shadowed_(false),
       in_spilled_code_(false) {
 }
 
 
 void CodeGenerator::SetFrame(VirtualFrame* new_frame) {
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     frame_->DetachFromCodeGenerator();
   }
   if (new_frame != NULL) {
     new_frame->AttachToCodeGenerator();
   }
   frame_ = new_frame;
 }
 
 
 void CodeGenerator::DeleteFrame() {
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     frame_->DetachFromCodeGenerator();
     delete frame_;
     frame_ = NULL;
   }
 }
 
 
 // Calling conventions:
 // ebp: frame pointer
 // esp: stack pointer
@@ skipping 166 matching lines @@
       if (should_trace) {
         frame_->CallRuntime(Runtime::kDebugTrace, 0);
         // Ignore the return value.
       }
 #endif
       VisitStatements(body);
 
       // Generate a return statement if necessary.  A NULL frame indicates
       // that control flow leaves the body on all paths and cannot fall
       // through.
-      if (frame_ != NULL) {
+      if (has_valid_frame()) {
         Literal undefined(Factory::undefined_value());
         ReturnStatement statement(&undefined);
         statement.set_statement_pos(fun->end_position());
         VisitReturnStatement(&statement);
       }
     }
   }
 
   // Adjust for function-level loop nesting.
   loop_nesting_ -= fun->loop_nesting();
@@ skipping 78 matching lines @@
                                   JumpTarget* true_target,
                                   JumpTarget* false_target,
                                   bool force_cc) {
   ASSERT(!in_spilled_code());
   ASSERT(!has_cc());
 
   { CodeGenState new_state(this, typeof_state, true_target, false_target);
     Visit(x);
   }
 
-  if (force_cc && frame_ != NULL && !has_cc()) {
+  if (force_cc && has_valid_frame() && !has_cc()) {
     // Convert the TOS value to a boolean in the condition code register.
     VirtualFrame::SpilledScope spilled_scope(this);
     ToBoolean(true_target, false_target);
   }
 
   ASSERT(!force_cc || frame_ == NULL || has_cc());
 }
 
 
 void CodeGenerator::Load(Expression* x, TypeofState typeof_state) {
   ASSERT(!in_spilled_code());
   JumpTarget true_target(this);
   JumpTarget false_target(this);
   LoadCondition(x, typeof_state, &true_target, &false_target, false);
 
   if (has_cc()) {
-    ASSERT(frame_ != NULL);
+    ASSERT(has_valid_frame());
     VirtualFrame::SpilledScope spilled_scope(this);
     // Convert cc_reg_ into a boolean value.
     JumpTarget loaded(this);
     JumpTarget materialize_true(this);
     materialize_true.Branch(cc_reg_);
     frame_->EmitPush(Immediate(Factory::false_value()));
     loaded.Jump();
     materialize_true.Bind();
     frame_->EmitPush(Immediate(Factory::true_value()));
     loaded.Bind();
     cc_reg_ = no_condition;
   }
 
   if (true_target.is_linked() || false_target.is_linked()) {
     // We have at least one condition value that has been "translated" into
     // a branch, thus it needs to be loaded explicitly.
     JumpTarget loaded(this);
-    if (frame_ != NULL) {
+    if (has_valid_frame()) {
       loaded.Jump();  // Don't lose the current TOS.
     }
     bool both = true_target.is_linked() && false_target.is_linked();
     // Load "true" if necessary.
     if (true_target.is_linked()) {
       true_target.Bind();
       VirtualFrame::SpilledScope spilled_scope(this);
       frame_->EmitPush(Immediate(Factory::true_value()));
     }
     // If both "true" and "false" need to be reincarnated jump across the
     // code for "false".
     if (both) {
       loaded.Jump();
     }
     // Load "false" if necessary.
     if (false_target.is_linked()) {
       false_target.Bind();
       VirtualFrame::SpilledScope spilled_scope(this);
       frame_->EmitPush(Immediate(Factory::false_value()));
     }
     // A value is loaded on all paths reaching this point.
     loaded.Bind();
   }
-  ASSERT(frame_ != NULL);
+  ASSERT(has_valid_frame());
   ASSERT(!has_cc());
 }
 
 
 void CodeGenerator::LoadGlobal() {
   frame_->EmitPush(GlobalObject());
 }
 
 
 void CodeGenerator::LoadGlobalReceiver(Register scratch) {
@@ skipping 888 matching lines @@
     // values including constants must be spilled to the frame.
     frame_->SpillAll();
     frame_->CallStub(&stub, 0);
     stack_is_ok.Bind();
   }
 }
 
 
 void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
   ASSERT(!in_spilled_code());
-  for (int i = 0; frame_ != NULL && i < statements->length(); i++) {
+  for (int i = 0; has_valid_frame() && i < statements->length(); i++) {
     Visit(statements->at(i));
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ Block");
   CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
@@ skipping 110 matching lines @@
   bool has_else_stm = node->HasElseStatement();
 
   CodeForStatement(node);
   JumpTarget exit(this);
   if (has_then_stm && has_else_stm) {
     JumpTarget then(this);
     JumpTarget else_(this);
     // if (cond)
     LoadConditionAndSpill(node->condition(), NOT_INSIDE_TYPEOF,
                           &then, &else_, true);
-    if (frame_ != NULL) {
-      // A NULL frame here indicates that the code for the condition cannot
-      // fall-through, i.e. it causes unconditional branchs to targets.
+    // An invalid frame here indicates that the code for the condition
+    // cannot fall-through, i.e. it caused unconditional jumps to the
+    // targets.
+    if (has_valid_frame()) {
       Branch(false, &else_);
     }
     // then
-    if (frame_ != NULL || then.is_linked()) {
+    if (has_valid_frame() || then.is_linked()) {
       // If control flow can reach the then part via fall-through from the
       // test or a branch to the target, compile it.
       then.Bind();
       VisitAndSpill(node->then_statement());
     }
-    if (frame_ != NULL) {
-      // A NULL frame here indicates that control did not fall out of the
-      // then statement, it escaped on all branches.  In that case, a jump
-      // to the exit label would be dead code (and impossible, because we
-      // don't have a current virtual frame to set at the exit label).
+    // A NULL frame here indicates that control did not fall out of the then
+    // statement, it escaped on all branches.  In that case, a jump to the
+    // exit label would be dead code (and impossible, because we don't have
+    // a current virtual frame to set at the exit label).
+    if (has_valid_frame()) {
       exit.Jump();
     }
     // else
     if (else_.is_linked()) {
       // Control flow for if-then-else does not fall-through to the else
       // part, it can only reach here via jump if at all.
       else_.Bind();
       VisitAndSpill(node->else_statement());
     }
 
   } else if (has_then_stm) {
     ASSERT(!has_else_stm);
     JumpTarget then(this);
     // if (cond)
     LoadConditionAndSpill(node->condition(), NOT_INSIDE_TYPEOF,
                           &then, &exit, true);
-    if (frame_ != NULL) {
+    if (has_valid_frame()) {
       Branch(false, &exit);
     }
     // then
-    if (frame_ != NULL || then.is_linked()) {
+    if (has_valid_frame() || then.is_linked()) {
       then.Bind();
       VisitAndSpill(node->then_statement());
     }
 
   } else if (has_else_stm) {
     ASSERT(!has_then_stm);
     JumpTarget else_(this);
     // if (!cond)
     LoadConditionAndSpill(node->condition(), NOT_INSIDE_TYPEOF,
                           &exit, &else_, true);
-    if (frame_ != NULL) {
+    if (has_valid_frame()) {
       Branch(true, &exit);
     }
     // else
-    if (frame_ != NULL || else_.is_linked()) {
+    if (has_valid_frame() || else_.is_linked()) {
       else_.Bind();
       VisitAndSpill(node->else_statement());
     }
 
   } else {
     ASSERT(!has_then_stm && !has_else_stm);
     // if (cond)
     LoadConditionAndSpill(node->condition(), NOT_INSIDE_TYPEOF,
                           &exit, &exit, false);
-    if (frame_ != NULL) {
+    if (has_valid_frame()) {
       if (has_cc()) {
         cc_reg_ = no_condition;
       } else {
         // No cc value set up, that means the boolean was pushed.
         // Pop it again, since it is not going to be used.
         frame_->Drop();
       }
     }
   }
 
@@ skipping 235 matching lines @@
     if (i > 0 && cases->at(i - 1)->is_default()) {
       default_exit.Bind();
     } else {
       fall_through.Bind();
       fall_through.Unuse();
     }
     VisitStatementsAndSpill(clause->statements());
 
     // If control flow can fall through from the body, jump to the next body
     // or the end of the statement.
-    if (frame_ != NULL) {
+    if (has_valid_frame()) {
       if (i < length - 1 && cases->at(i + 1)->is_default()) {
         default_entry.Jump();
       } else {
         fall_through.Jump();
       }
     }
   }
 
   // The final "test" removes the switch value.
   next_test.Bind();
   frame_->Drop();
 
   // If there is a default clause, compile it.
   if (default_clause != NULL) {
     Comment cmnt(masm_, "[ Default clause");
     default_entry.Bind();
     VisitStatementsAndSpill(default_clause->statements());
-    if (frame_ != NULL) {
-    }
     // If control flow can fall out of the default and there is a case after
     // it, jump to that case's body.
-    if (frame_ != NULL && default_exit.is_bound()) {
+    if (has_valid_frame() && default_exit.is_bound()) {
       default_exit.Jump();
     }
   }
 
   if (fall_through.is_linked()) {
     fall_through.Bind();
   }
 
   if (node->break_target()->is_linked()) {
     node->break_target()->Bind();
@@ skipping 39 matching lines @@
         // There is no need, we will never jump back.
       } else {
         ASSERT(info == DONT_KNOW);
         body.Bind();
       }
       CheckStack();  // TODO(1222600): ignore if body contains calls.
       VisitAndSpill(node->body());
 
       // Compile the "test".
       if (info == ALWAYS_TRUE) {
-        if (frame_ != NULL) {
+        if (has_valid_frame()) {
           // If control flow can fall off the end of the body, jump back to
           // the top.
           node->continue_target()->Jump();
         }
       } else if (info == ALWAYS_FALSE) {
         // If we have a continue in the body, we only have to bind its jump
         // target.
         if (node->continue_target()->is_linked()) {
           node->continue_target()->Bind();
         }
       } else {
         ASSERT(info == DONT_KNOW);
         // We have to compile the test expression if it can be reached by
         // control flow falling out of the body or via continue.
-        if (frame_ != NULL || node->continue_target()->is_linked()) {
+        if (has_valid_frame() || node->continue_target()->is_linked()) {
           node->continue_target()->Bind();
           LoadConditionAndSpill(node->cond(), NOT_INSIDE_TYPEOF,
                                 &body, node->break_target(), true);
-          if (frame_ != NULL) {
-            // A NULL frame here indicates that control flow did not fall
-            // out of the test expression.
+          // An invalid frame here indicates that control flow did not fall
+          // out of the test expression.
+          if (has_valid_frame()) {
             Branch(true, &body);
           }
         }
       }
       break;
     }
 
     case LoopStatement::WHILE_LOOP: {
       // The new code generator does not yet compile while loops.
       VirtualFrame::SpilledScope spilled_scope(this);
       JumpTarget body(this);
       IncrementLoopNesting();
       // Generate the loop header.
       if (info == ALWAYS_TRUE) {
         // Merely label the body with the continue target.
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
         // There is no need to even compile the test or body.
         break;
       } else {
         // Compile the test labeled with the continue target and label the
         // body with the body target.
         ASSERT(info == DONT_KNOW);
         node->continue_target()->Bind();
         LoadConditionAndSpill(node->cond(), NOT_INSIDE_TYPEOF,
                               &body, node->break_target(), true);
-        if (frame_ != NULL) {
-          // A NULL frame indicates that control did not fall out of the
-          // test expression.
+        // An invalid frame indicates that control did not fall out of the
+        // test expression.
+        if (has_valid_frame()) {
           Branch(false, node->break_target());
         }
-        if (frame_ != NULL || body.is_linked()) {
+        if (has_valid_frame() || body.is_linked()) {
           body.Bind();
         }
       }
-      if (frame_ != NULL) {
+      if (has_valid_frame()) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         VisitAndSpill(node->body());
 
         // If control flow can fall out of the body, jump back to the top.
-        if (frame_ != NULL) {
+        if (has_valid_frame()) {
           node->continue_target()->Jump();
         }
       }
       break;
     }
 
     case LoopStatement::FOR_LOOP: {
       JumpTarget loop(this);
       JumpTarget body(this);
       if (node->init() != NULL) {
@@ skipping 10 matching lines @@
       if (node->next() == NULL) {
         node->continue_target()->Bind();
       } else {
         loop.Bind();
       }
 
       // If the test is always true, there is no need to compile it.
       if (info == DONT_KNOW) {
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                       &body, node->break_target(), true);
-        if (frame_ != NULL) {
+        if (has_valid_frame()) {
           Branch(false, node->break_target());
         }
-        if (frame_ != NULL || body.is_linked()) {
+        if (has_valid_frame() || body.is_linked()) {
           body.Bind();
         }
       }
 
-      if (frame_ != NULL) {
+      if (has_valid_frame()) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         if (node->next() == NULL) {
           // If there is no update statement and control flow can fall out
           // of the loop, jump to the continue label.
-          if (frame_ != NULL) {
+          if (has_valid_frame()) {
             node->continue_target()->Jump();
           }
         } else {
           // If there is an update statement and control flow can reach it
           // via falling out of the body of the loop or continuing, we
           // compile the update statement.
-          if (frame_ != NULL || node->continue_target()->is_linked()) {
+          if (has_valid_frame() || node->continue_target()->is_linked()) {
             node->continue_target()->Bind();
             // Record source position of the statement as this code which is
             // after the code for the body actually belongs to the loop
             // statement and not the body.
             CodeForStatement(node);
             ASSERT(node->type() == LoopStatement::FOR_LOOP);
             Visit(node->next());
             loop.Jump();
           }
         }
@@ skipping 215 matching lines @@
     // Load the exception to the top of the stack.  Here we make use of the
     // convenient property that it doesn't matter whether a value is
     // immediately on top of or underneath a zero-sized reference.
     ref.SetValue(NOT_CONST_INIT);
   }
 
   // Remove the exception from the stack.
   frame_->Drop();
 
   VisitStatementsAndSpill(node->catch_block()->statements());
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     exit.Jump();
   }
 
 
   // --- Try block ---
   try_block.Bind();
 
   frame_->PushTryHandler(TRY_CATCH_HANDLER);
   int handler_height = frame_->height();
 
@@ skipping 34 matching lines @@
   // Make sure that there's nothing left on the stack above the
   // handler structure.
   if (FLAG_debug_code) {
     __ mov(eax, Operand::StaticVariable(handler_address));
     __ lea(eax, Operand(eax, StackHandlerConstants::kAddressDisplacement));
     __ cmp(esp, Operand(eax));
     __ Assert(equal, "stack pointer should point to top handler");
   }
 
   // If we can fall off the end of the try block, unlink from try chain.
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     frame_->EmitPop(eax);
     __ mov(Operand::StaticVariable(handler_address), eax);  // TOS == next_sp
     frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
     // next_sp popped.
     if (nof_unlinks > 0) {
       exit.Jump();
     }
   }
 
   // Generate unlink code for the (formerly) shadowing targets that have been
@@ skipping 77 matching lines @@
   // ShadowTargets represent the formerly shadowing targets.
   int nof_unlinks = 0;
   for (int i = 0; i <= nof_escapes; i++) {
     shadows[i]->StopShadowing();
     if (shadows[i]->is_linked()) nof_unlinks++;
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
 
   // If we can fall off the end of the try block, set the state on the stack
   // to FALLING.
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     frame_->EmitPush(Immediate(Factory::undefined_value()));  // fake TOS
     __ Set(ecx, Immediate(Smi::FromInt(FALLING)));
     if (nof_unlinks > 0) {
       unlink.Jump();
     }
   }
 
   // Generate code to set the state for the (formerly) shadowing targets that
   // have been jumped to.
   for (int i = 0; i <= nof_escapes; i++) {
@@ skipping 40 matching lines @@
   // and the state - while evaluating the finally block. Record it, so
   // that a break/continue crossing this statement can restore the
   // stack.
   const int kFinallyStackSize = 2 * kPointerSize;
   break_stack_height_ += kFinallyStackSize;
 
   // Generate code for the statements in the finally block.
   VisitStatementsAndSpill(node->finally_block()->statements());
 
   break_stack_height_ -= kFinallyStackSize;
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     JumpTarget exit(this);
     // Restore state and return value or faked TOS.
     frame_->EmitPop(ecx);
     frame_->EmitPop(eax);
 
     // Generate code to jump to the right destination for all used
     // (formerly) shadowing targets.
     for (int i = 0; i <= nof_escapes; i++) {
       if (shadows[i]->is_bound()) {
         __ cmp(Operand(ecx), Immediate(Smi::FromInt(JUMPING + i)));
@@ skipping 59 matching lines @@
 
 
 void CodeGenerator::VisitConditional(Conditional* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ Conditional");
   JumpTarget then(this);
   JumpTarget else_(this);
   JumpTarget exit(this);
   LoadConditionAndSpill(node->condition(), NOT_INSIDE_TYPEOF,
                         &then, &else_, true);
-  if (frame_ != NULL) {
+  if (has_valid_frame()) {
     Branch(false, &else_);
   }
-  if (frame_ != NULL || then.is_linked()) {
+  if (has_valid_frame() || then.is_linked()) {
     then.Bind();
     LoadAndSpill(node->then_expression(), typeof_state());
     exit.Jump();
   }
   if (else_.is_linked()) {
     else_.Bind();
     LoadAndSpill(node->else_expression(), typeof_state());
   }
   exit.Bind();
 }
@@ skipping 142 matching lines @@
   Expression* expr = var->rewrite();
   if (expr != NULL) {
     // We have to be wary of calling Visit directly on expressions.  Because
     // of special casing comparisons of the form typeof<expr> === "string",
     // we can return from a call from Visit (to a comparison or a unary
     // operation) without a virtual frame; which will probably crash if we
     // try to emit frame code before reestablishing a frame.  Here we're
     // safe as long as variable proxies can't rewrite into typeof
     // comparisons or unary logical not expressions.
     Visit(expr);
-    ASSERT(frame_ != NULL);
+    ASSERT(has_valid_frame());
   } else {
     ASSERT(var->is_global());
     Reference ref(this, node);
     ref.GetValue(typeof_state());
   }
 }
 
 
 void CodeGenerator::VisitLiteral(Literal* node) {
   Comment cmnt(masm_, "[ Literal");
@@ skipping 1155 matching lines @@
   // after evaluating the left hand side (due to the shortcut
   // semantics), but the compiler must (statically) know if the result
   // of compiling the binary operation is materialized or not.
 
   if (op == Token::AND) {
     JumpTarget is_true(this);
     LoadConditionAndSpill(node->left(), NOT_INSIDE_TYPEOF,
                           &is_true, false_target(), false);
     if (has_cc() || frame_ == NULL) {
       if (has_cc()) {
-        ASSERT(frame_ != NULL);
+        ASSERT(has_valid_frame());
         Branch(false, false_target());
       }
 
-      if (frame_ != NULL || is_true.is_linked()) {
+      if (has_valid_frame() || is_true.is_linked()) {
         // Evaluate right side expression.
         is_true.Bind();
         LoadConditionAndSpill(node->right(), NOT_INSIDE_TYPEOF,
                               true_target(), false_target(), false);
       }
     } else {
       // We have a materialized value on the frame.
       JumpTarget pop_and_continue(this);
       JumpTarget exit(this);
 
@@ skipping 18 matching lines @@
       // Exit (always with a materialized value).
       exit.Bind();
     }
 
   } else if (op == Token::OR) {
     JumpTarget is_false(this);
     LoadConditionAndSpill(node->left(), NOT_INSIDE_TYPEOF,
                           true_target(), &is_false, false);
     if (has_cc() || frame_ == NULL) {
       if (has_cc()) {
-        ASSERT(frame_ != NULL);
+        ASSERT(has_valid_frame());
         Branch(true, true_target());
       }
 
-      if (frame_ != NULL || is_false.is_linked()) {
+      if (has_valid_frame() || is_false.is_linked()) {
         // Evaluate right side expression.
         is_false.Bind();
         LoadConditionAndSpill(node->right(), NOT_INSIDE_TYPEOF,
                               true_target(), false_target(), false);
       }
 
     } else {
       // We have a materialized value on the frame.
       JumpTarget pop_and_continue(this);
       JumpTarget exit(this);
@@ skipping 1829 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal