Experimental: remove the cc_reg_ state from the code generator. There...

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 63 matching lines @@
 
 CodeGenerator::CodeGenerator(int buffer_size, Handle<Script> script,
                              bool is_eval)
     : is_eval_(is_eval),
       script_(script),
       deferred_(8),
       masm_(new MacroAssembler(NULL, buffer_size)),
       scope_(NULL),
       frame_(NULL),
       allocator_(NULL),
-      cc_reg_(no_condition),
       state_(NULL),
       break_stack_height_(0),
       loop_nesting_(0),
       function_return_is_shadowed_(false),
       in_spilled_code_(false) {
 }
 
 
 void CodeGenerator::SetFrame(VirtualFrame* new_frame,
                              RegisterFile* non_frame_registers) {
@@ skipping 37 matching lines @@
   ZoneList<Statement*>* body = fun->body();
 
   // Initialize state.
   ASSERT(scope_ == NULL);
   scope_ = fun->scope();
   ASSERT(allocator_ == NULL);
   RegisterAllocator register_allocator(this);
   allocator_ = &register_allocator;
   ASSERT(frame_ == NULL);
   frame_ = new VirtualFrame(this);
-  cc_reg_ = no_condition;
   function_return_.set_code_generator(this);
   function_return_is_shadowed_ = false;
   set_in_spilled_code(false);
 
   // Adjust for function-level loop nesting.
   loop_nesting_ += fun->loop_nesting();
 
   {
     CodeGenState state(this);
 
@@ skipping 170 matching lines @@
   }
 
   // Adjust for function-level loop nesting.
   loop_nesting_ -= fun->loop_nesting();
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(loop_nesting() == 0);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
-  ASSERT(!has_cc());
   DeleteFrame();
 
   // Process any deferred code using the register allocator.
   ProcessDeferred();
 
   // There is no need to delete the register allocator, it is a
   // stack-allocated local.
   allocator_ = NULL;
   scope_ = NULL;
 }
@@ skipping 43 matching lines @@
       return ContextOperand(tmp, index);
     }
 
     default:
       UNREACHABLE();
       return Operand(eax);
   }
 }
 
 
-// Loads a value on TOS. If it is a boolean value, the result may have been
-// (partially) translated into branches, or it may have set the condition
-// code register. If force_cc is set, the value is forced to set the
-// condition code register and no value is pushed. If the condition code
-// register was set, has_cc() is true and cc_reg_ contains the condition to
-// test for 'true'.
+// Loads a value on TOS. If the result is a boolean value it may have
+// been translated into control flow to the true and/or false targets.
+// If force_control is true, control flow is forced and the function
+// exits without a valid frame.
 void CodeGenerator::LoadCondition(Expression* x,
                                   TypeofState typeof_state,
                                   JumpTarget* true_target,
                                   JumpTarget* false_target,
-                                  bool force_cc) {
+                                  bool force_control) {
   ASSERT(!in_spilled_code());
-  ASSERT(!has_cc());
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   { CodeGenState new_state(this, typeof_state, true_target, false_target);
     Visit(x);
   }
 
-  if (force_cc && has_valid_frame() && !has_cc()) {
+  if (force_control && has_valid_frame()) {
     // Convert the TOS value to a boolean in the condition code register.
     ToBoolean(true_target, false_target);
   }
 
-  ASSERT(!force_cc || frame_ == NULL || has_cc());
-  ASSERT(!has_valid_frame() ||
-         (has_cc() && frame_->height() == original_height) ||
-         (!has_cc() && frame_->height() == original_height + 1));
+  ASSERT(!(force_control && has_valid_frame()));
+  ASSERT(!has_valid_frame() || frame_->height() == original_height + 1);
 }
 
 
 void CodeGenerator::Load(Expression* x, TypeofState typeof_state) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   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(has_valid_frame());
-    VirtualFrame::SpilledScope spilled_scope(this);
-    // Convert cc_reg_ into a boolean value.
-    JumpTarget loaded(this);
-    JumpTarget materialize_true(this);
-    Condition cc = cc_reg_;
-    cc_reg_ = no_condition;
-    materialize_true.Branch(cc);
-    frame_->EmitPush(Immediate(Factory::false_value()));
-    loaded.Jump();
-    materialize_true.Bind();
-    frame_->EmitPush(Immediate(Factory::true_value()));
-    loaded.Bind();
-  }
-
   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 (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(has_valid_frame());
-  ASSERT(!has_cc());
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 void CodeGenerator::LoadGlobal() {
   if (in_spilled_code()) {
     frame_->EmitPush(GlobalObject());
   } else {
     Result temp = allocator_->Allocate();
     __ mov(temp.reg(), GlobalObject());
@@ skipping 143 matching lines @@
   false_target->Branch(zero);
   __ test(value.reg(), Immediate(kSmiTagMask));
   true_target->Branch(zero);
 
   // Call the stub for all other cases.
   frame_->Push(&value);  // Undo the Pop() from above.
   ToBooleanStub stub;
   Result temp = frame_->CallStub(&stub, 1);
   // Convert the result to a condition code.
   __ test(temp.reg(), Operand(temp.reg()));
-
-  ASSERT(not_equal == not_zero);
-  cc_reg_ = not_equal;
+  temp.Unuse();
+  true_target->Branch(not_equal);
+  false_target->Jump();
 }
 
 
 class FloatingPointHelper : public AllStatic {
  public:
   // Code pattern for loading floating point values. Input values must
   // be either smi or heap number objects (fp values). Requirements:
   // operand_1 on TOS+1 , operand_2 on TOS+2; Returns operands as
   // floating point numbers on FPU stack.
   static void LoadFloatOperands(MacroAssembler* masm, Register scratch);
@@ skipping 538 matching lines @@
 #ifdef DEBUG
   void Print() {
     PrintF("CompareStub (cc %d), (strict %s)\n",
            static_cast<int>(cc_),
            strict_ ? "true" : "false");
   }
 #endif
 };
 
 
-void CodeGenerator::Comparison(Condition cc, bool strict) {
+void CodeGenerator::Comparison(Condition cc,
+                               bool strict,
+                               JumpTarget* true_target,
+                               JumpTarget* false_target) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   Result left_side(this);
   Result right_side(this);
   // Implement '>' and '<=' by reversal to obtain ECMA-262 conversion order.
   if (cc == greater || cc == less_equal) {
     cc = ReverseCondition(cc);
     left_side = frame_->Pop();
     right_side = frame_->Pop();
@@ skipping 65 matching lines @@
   }
   __ cmp(left_side.reg(), Operand(right_side.reg()));
   right_side.Unuse();
   left_side.Unuse();
   __ setcc(cc, answer.reg());
   __ and_(Operand(answer.reg()), Immediate(1));
 
   done.Bind(&answer);
   answer.ToRegister();
   __ test(answer.reg(), Operand(answer.reg()));
-  cc_reg_ = not_zero;
+  answer.Unuse();
+  true_target->Branch(not_zero);
+  false_target->Jump();
 }
 
 
 class DeferredSmiComparison: public DeferredCode {
  public:
   DeferredSmiComparison(CodeGenerator* generator,
                         Condition cc,
                         bool strict,
                         int int_value) :
       DeferredCode(generator),
@@ skipping 62 matching lines @@
   }
   // Test smi equality and comparison by signed int comparison.
   __ cmp(Operand(comparee.reg()), Immediate(value));
   comparee.Unuse();
   __ setcc(cc, flag.reg());
   __ and_(Operand(flag.reg()), Immediate(1));
 
   deferred->exit()->Bind(&flag);
   flag.ToRegister();
   __ test(flag.reg(), Operand(flag.reg()));
-  cc_reg_ = not_zero;
+  flag.Unuse();
+  true_target()->Branch(not_zero);
+  false_target()->Jump();
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
@@ skipping 24 matching lines @@
   // Use the shared code stub to call the function.
   CallFunctionStub call_function(arg_count);
   Result answer = frame_->CallStub(&call_function, arg_count + 1);
   // Restore context and replace function on the stack with the
   // result of the stub invocation.
   frame_->RestoreContextRegister();
   frame_->SetElementAt(0, &answer);
 }
 
 
-void CodeGenerator::Branch(bool if_true, JumpTarget* target) {
-  ASSERT(has_cc());
-  Condition cc = if_true ? cc_reg_ : NegateCondition(cc_reg_);
-  cc_reg_ = no_condition;
-  target->Branch(cc);
-}
-
-
 void CodeGenerator::CheckStack() {
   if (FLAG_check_stack) {
     JumpTarget stack_is_ok(this);
     StackCheckStub stub;
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     stack_is_ok.Branch(above_equal, taken);
     // The stack check can trigger the debugger.  Before calling it, all
     // values including constants must be spilled to the frame.
@@ skipping 126 matching lines @@
   // are present or not.
   bool has_then_stm = node->HasThenStatement();
   bool has_else_stm = node->HasElseStatement();
 
   CodeForStatement(node);
   JumpTarget exit(this);
   if (has_then_stm && has_else_stm) {
     JumpTarget then(this);
     JumpTarget else_(this);
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
-    if (has_valid_frame()) {
-      // We have fallen through from the condition (with a value in cc_reg).
-      // Emit a branch if false around the then block and compile both
-      // blocks.
-      Branch(false, &else_);
-    }
     if (then.is_linked()) {
       then.Bind();
-    }
-    if (has_valid_frame()) {
-      // We have fallen through from the condition or reached here by a
-      // direct jump to the then target.
       Visit(node->then_statement());
-    }
-    if (has_valid_frame() && else_.is_linked()) {
-      // We have fallen through from the then block and we need to compile
-      // the else block.  Emit an unconditional jump around it.
-      exit.Jump();
+      if (has_valid_frame() && else_.is_linked()) {
+        // We have fallen through from the then block and we need to compile
+        // the else block.  Emit an unconditional jump around it.
+        exit.Jump();
+      }
     }
     if (else_.is_linked()) {
       else_.Bind();
       Visit(node->else_statement());
     }
 
   } else if (has_then_stm) {
     ASSERT(!has_else_stm);
     JumpTarget then(this);
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &exit, true);
-    if (has_valid_frame()) {
-      // We have fallen through from the condition (with a value in cc_reg).
-      // Emit a branch if false around the then block.
-      Branch(false, &exit);
-    }
     if (then.is_linked()) {
       then.Bind();
-    }
-    if (has_valid_frame()) {
-      // We have fallen through from the condition or reached here by a
-      // direct jump to the then target.
       Visit(node->then_statement());
     }
 
   } else if (has_else_stm) {
     ASSERT(!has_then_stm);
     JumpTarget else_(this);
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &exit, &else_, true);
-    if (has_valid_frame()) {
-      // We have fallen through from the condition (with a value in cc_reg).
-      // Emit a branch if true around the else block.
-      Branch(true, &exit);
-    }
     if (else_.is_linked()) {
       else_.Bind();
-    }
-    if (has_valid_frame()) {
-      // We have fallen through from the condition or reached here by a
-      // direct jump to the else target.
       Visit(node->else_statement());
     }
 
   } else {
     ASSERT(!has_then_stm && !has_else_stm);
-    // We only care about the condition's side effects (not its value or
-    // control flow effect).  LoadCondition is called without forcing a
-    // value into cc_reg.
+    // We only care about the condition's side effects (not its value
+    // or control flow effect).  LoadCondition is called without
+    // forcing control flow.
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &exit, &exit, false);
     if (has_valid_frame()) {
-      // Control flow can fall off the end of the condition.  We discard its
-      // value, which may be in cc_reg or else on top of the virtual frame.
-      if (has_cc()) {
-        cc_reg_ = no_condition;
-      } else {
-        frame_->Drop();
-      }
+      // Control flow can fall off the end of the condition with a
+      // value on the frame.
+      frame_->Drop();
     }
   }
 
   if (exit.is_linked()) {
     exit.Bind();
   }
 }
 
 
 void CodeGenerator::CleanStack(int num_bytes) {
@@ skipping 239 matching lines @@
     Comment cmnt(masm_, "[ Case clause");
     // Label and compile the test.
     if (next_test.is_linked()) {
       // Recycle the same label for each test.
       next_test.Bind();
       next_test.Unuse();
     }
     // Duplicate the switch value.
     frame_->Dup();
     Load(clause->label());
-    Comparison(equal, true);
-    Branch(false, &next_test);
+    JumpTarget enter_body(this);
+    Comparison(equal, true, &enter_body, &next_test);
 
     // Before entering the body from the test remove the switch value from
     // the frame.
+    enter_body.Bind();
     frame_->Drop();
 
     // Label the body so that fall through is enabled.
     if (i > 0 && cases->at(i - 1)->is_default()) {
       // The previous case was the default.  This will be the target of a
       // possible backward edge.
       default_exit.Bind();
     } else if (fall_through.is_linked()) {
       // Recycle the same label for each fall through except for the default
       // case.
@@ skipping 100 matching lines @@
       } 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 (node->continue_target()->is_linked()) {
           node->continue_target()->Bind();
         }
         if (has_valid_frame()) {
           LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                         &body, node->break_target(), true);
-          // 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: {
       IncrementLoopNesting();
 
       // If the test is never true and has no side effects there is no need
       // to compile the test or body.
       if (info == ALWAYS_FALSE) break;
 
       // Label the top of the loop with the continue target for the backward
       // CFG edge.
       node->continue_target()->Bind();
 
       // If the test is always true and has no side effects there is no need
       // to compile it.  We only compile the test when we do not know its
       // outcome or it may have side effects.
       if (info == DONT_KNOW) {
         JumpTarget body(this);
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                       &body, node->break_target(), true);
-        // An invalid frame indicates that control did not fall out of the
-        // test expression.
-        if (has_valid_frame()) {
-          Branch(false, node->break_target());
-        }
         if (body.is_linked()) {
           body.Bind();
         }
       }
 
       if (has_valid_frame()) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         // If control flow can fall out of the body, jump back to the top.
@@ skipping 23 matching lines @@
         loop.Bind();
       }
 
       // If the test is always true and has no side effects there is no need
       // to compile it.  We only compile the test when we do not know its
       // outcome or it has side effects.
       if (info == DONT_KNOW) {
         JumpTarget body(this);
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                       &body, node->break_target(), true);
-        if (has_valid_frame()) {
-          Branch(false, node->break_target());
-        }
         if (body.is_linked()) {
           body.Bind();
         }
       }
 
       if (has_valid_frame()) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         if (node->next() == NULL) {
@@ skipping 562 matching lines @@
   InstantiateBoilerplate(node->boilerplate());
 }
 
 
 void CodeGenerator::VisitConditional(Conditional* node) {
   Comment cmnt(masm_, "[ Conditional");
   JumpTarget then(this);
   JumpTarget else_(this);
   JumpTarget exit(this);
   LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
-  if (has_valid_frame()) {
-    Branch(false, &else_);
-  }
   if (then.is_linked()) {
     then.Bind();
+    Load(node->then_expression(), typeof_state());
+    if (else_.is_linked()) {
+      exit.Jump();
+    }
   }
-  if (has_valid_frame()) {
-    Load(node->then_expression(), typeof_state());
-    exit.Jump();
-  }
+
   if (else_.is_linked()) {
     else_.Bind();
     Load(node->else_expression(), typeof_state());
   }
-  exit.Bind();
+
+  if (exit.is_linked()) {
+    exit.Bind();
+  }
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
     frame_->Push(esi);
     frame_->Push(slot->var()->name());
@@ skipping 731 matching lines @@
   frame_->RestoreContextRegister();
   __ mov(frame_->Top(), eax);
 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   LoadAndSpill(args->at(0));
   frame_->EmitPop(eax);
   __ test(eax, Immediate(kSmiTagMask));
-  cc_reg_ = zero;
+  true_target()->Branch(zero);
+  false_target()->Jump();
 }
 
 
 void CodeGenerator::GenerateLog(ZoneList<Expression*>* args) {
   // Conditionally generate a log call.
   // Args:
   //   0 (literal string): The type of logging (corresponds to the flags).
   //     This is used to determine whether or not to generate the log call.
   //   1 (string): Format string.  Access the string at argument index 2
   //     with '%2s' (see Logger::LogRuntime for all the formats).
   //   2 (array): Arguments to the format string.
   ASSERT_EQ(args->length(), 3);
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (ShouldGenerateLog(args->at(0))) {
     LoadAndSpill(args->at(1));
     LoadAndSpill(args->at(2));
     frame_->CallRuntime(Runtime::kLog, 2);
   }
 #endif
   // Finally, we're expected to leave a value on the top of the stack.
   frame_->EmitPush(Immediate(Factory::undefined_value()));
 }
 
 
 void CodeGenerator::GenerateIsNonNegativeSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   LoadAndSpill(args->at(0));
   frame_->EmitPop(eax);
   __ test(eax, Immediate(kSmiTagMask | 0x80000000));
-  cc_reg_ = zero;
+  true_target()->Branch(zero);
+  false_target()->Jump();
 }
 
 
 // This generates code that performs a charCodeAt() call or returns
 // undefined in order to trigger the slow case, Runtime_StringCharCodeAt.
 // It can handle flat and sliced strings, 8 and 16 bit characters and
 // cons strings where the answer is found in the left hand branch of the
 // cons.  The slow case will flatten the string, which will ensure that
 // the answer is in the left hand side the next time around.
 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) {
@@ skipping 103 matching lines @@
   slow_case.Bind();
   frame_->EmitPush(Immediate(Factory::undefined_value()));
 
   end.Bind();
 }
 
 
 void CodeGenerator::GenerateIsArray(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   LoadAndSpill(args->at(0));
-  Label answer;
   // We need the CC bits to come out as not_equal in the case where the
   // object is a smi.  This can't be done with the usual test opcode so
   // we copy the object to ecx and do some destructive ops on it that
   // result in the right CC bits.
   frame_->EmitPop(eax);
   __ mov(ecx, Operand(eax));
   __ and_(ecx, kSmiTagMask);
   __ xor_(ecx, kSmiTagMask);
-  __ j(not_equal, &answer, not_taken);
+  false_target()->Branch(not_equal);
   // It is a heap object - get map.
   __ mov(eax, FieldOperand(eax, HeapObject::kMapOffset));
   __ movzx_b(eax, FieldOperand(eax, Map::kInstanceTypeOffset));
   // Check if the object is a JS array or not.
   __ cmp(eax, JS_ARRAY_TYPE);
-  __ bind(&answer);
-  cc_reg_ = equal;
+  true_target()->Branch(equal);
+  false_target()->Jump();
 }
 
 
 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 0);
 
   // Seed the result with the formal parameters count, which will be
   // used in case no arguments adaptor frame is found below the
   // current frame.
   __ Set(eax, Immediate(Smi::FromInt(scope_->num_parameters())));
@@ skipping 70 matching lines @@
 
 void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
 
   // Load the two objects into registers and perform the comparison.
   LoadAndSpill(args->at(0));
   LoadAndSpill(args->at(1));
   frame_->EmitPop(eax);
   frame_->EmitPop(ecx);
   __ cmp(eax, Operand(ecx));
-  cc_reg_ = equal;
+  true_target()->Branch(equal);
+  false_target()->Jump();
 }
 
 
 void CodeGenerator::VisitCallRuntime(CallRuntime* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   if (CheckForInlineRuntimeCall(node)) {
     return;
   }
 
   ZoneList<Expression*>* args = node->arguments();
@@ skipping 34 matching lines @@
   // expression to a literal string, this function can fail to leave a value
   // on top of the frame or in the cc register.
   Comment cmnt(masm_, "[ UnaryOperation");
 
   Token::Value op = node->op();
 
   if (op == Token::NOT) {
     VirtualFrame::SpilledScope spilled_scope(this);
     LoadConditionAndSpill(node->expression(), NOT_INSIDE_TYPEOF,
                           false_target(), true_target(), true);
-    cc_reg_ = NegateCondition(cc_reg_);
 
   } else if (op == Token::DELETE) {
     VirtualFrame::SpilledScope spilled_scope(this);
     Property* property = node->expression()->AsProperty();
     if (property != NULL) {
       LoadAndSpill(property->obj());
       LoadAndSpill(property->key());
       frame_->InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION, 2);
       frame_->EmitPush(eax);
       return;
@@ skipping 314 matching lines @@
   // the CC register), we force the right hand side to do the
   // same. This is necessary because we may have to branch to the exit
   // 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);
     LoadCondition(node->left(), NOT_INSIDE_TYPEOF,
                   &is_true, false_target(), false);
-    if (has_cc() || frame_ == NULL) {
-      if (has_cc()) {
-        ASSERT(has_valid_frame());
-        Branch(false, false_target());
-      }
-
+    if (!has_valid_frame()) {
       if (is_true.is_linked()) {
+        // Evaluate right side expression.
         is_true.Bind();
-      }
-      if (has_valid_frame()) {
-        // Evaluate right side expression.
         LoadCondition(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);
 
       // Avoid popping the result if it converts to 'false' using the
       // standard ToBoolean() conversion as described in ECMA-262, section
       // 9.2, page 30.
       //
       // Duplicate the TOS value. The duplicate will be popped by ToBoolean.
       frame_->Dup();
       ToBoolean(&pop_and_continue, &exit);
-      Branch(false, &exit);
 
       // Pop the result of evaluating the first part.
       pop_and_continue.Bind();
       frame_->Drop();
 
       // Evaluate right side expression.
       is_true.Bind();
       Load(node->right());
 
       // Exit (always with a materialized value).
       exit.Bind();
     }
 
   } else if (op == Token::OR) {
     JumpTarget is_false(this);
     LoadCondition(node->left(), NOT_INSIDE_TYPEOF,
                   true_target(), &is_false, false);
-    if (has_cc() || frame_ == NULL) {
-      if (has_cc()) {
-        ASSERT(has_valid_frame());
-        Branch(true, true_target());
-      }
-
+    if (!has_valid_frame()) {
       if (is_false.is_linked()) {
         // Evaluate right side expression.
         is_false.Bind();
-      }
-      if (has_valid_frame()) {
         LoadCondition(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);
 
       // Avoid popping the result if it converts to 'true' using the
       // standard ToBoolean() conversion as described in ECMA-262,
       // section 9.2, page 30.
       // Duplicate the TOS value. The duplicate will be popped by ToBoolean.
       frame_->Dup();
       ToBoolean(&exit, &pop_and_continue);
-      Branch(true, &exit);
 
       // Pop the result of evaluating the first part.
       pop_and_continue.Bind();
       frame_->Drop();
 
       // Evaluate right side expression.
       is_false.Bind();
       Load(node->right());
 
       // Exit (always with a materialized value).
@@ skipping 87 matching lines @@
         __ test(eax, Immediate(kSmiTagMask));
         false_target()->Branch(equal);
 
         // It can be an undetectable object.
         __ mov(eax, FieldOperand(eax, HeapObject::kMapOffset));
         __ movzx_b(eax, FieldOperand(eax, Map::kBitFieldOffset));
         __ and_(eax, 1 << Map::kIsUndetectable);
         __ cmp(eax, 1 << Map::kIsUndetectable);
       }
 
-      cc_reg_ = equal;
+      true_target()->Branch(equal);
+      false_target()->Jump();
       return;
     }
   }
 
   // To make typeof testing for natives implemented in JavaScript really
   // efficient, we generate special code for expressions of the form:
   // 'typeof <expression> == <string>'.
   UnaryOperation* operation = left->AsUnaryOperation();
   if ((op == Token::EQ || op == Token::EQ_STRICT) &&
       (operation != NULL && operation->op() == Token::TYPEOF) &&
       (right->AsLiteral() != NULL &&
        right->AsLiteral()->handle()->IsString())) {
     Handle<String> check(String::cast(*right->AsLiteral()->handle()));
 
     VirtualFrame::SpilledScope spilled_scope(this);
     // Load the operand and move it to register edx.
     LoadTypeofExpression(operation->expression());
     frame_->EmitPop(edx);
 
     if (check->Equals(Heap::number_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       true_target()->Branch(zero);
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
       __ cmp(edx, Factory::heap_number_map());
-      cc_reg_ = equal;
+      true_target()->Branch(equal);
+      false_target()->Jump();
 
     } else if (check->Equals(Heap::string_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       false_target()->Branch(zero);
 
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
 
       // It can be an undetectable string object.
       __ movzx_b(ecx, FieldOperand(edx, Map::kBitFieldOffset));
       __ and_(ecx, 1 << Map::kIsUndetectable);
       __ cmp(ecx, 1 << Map::kIsUndetectable);
       false_target()->Branch(equal);
 
       __ movzx_b(ecx, FieldOperand(edx, Map::kInstanceTypeOffset));
       __ cmp(ecx, FIRST_NONSTRING_TYPE);
-      cc_reg_ = less;
+      true_target()->Branch(less);
+      false_target()->Jump();
 
     } else if (check->Equals(Heap::boolean_symbol())) {
       __ cmp(edx, Factory::true_value());
       true_target()->Branch(equal);
       __ cmp(edx, Factory::false_value());
-      cc_reg_ = equal;
+      true_target()->Branch(equal);
+      false_target()->Jump();
 
     } else if (check->Equals(Heap::undefined_symbol())) {
       __ cmp(edx, Factory::undefined_value());
       true_target()->Branch(equal);
 
       __ test(edx, Immediate(kSmiTagMask));
       false_target()->Branch(zero);
 
       // It can be an undetectable object.
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
       __ movzx_b(ecx, FieldOperand(edx, Map::kBitFieldOffset));
       __ and_(ecx, 1 << Map::kIsUndetectable);
       __ cmp(ecx, 1 << Map::kIsUndetectable);
-
-      cc_reg_ = equal;
+      true_target()->Branch(equal);
+      false_target()->Jump();
 
     } else if (check->Equals(Heap::function_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       false_target()->Branch(zero);
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
       __ movzx_b(edx, FieldOperand(edx, Map::kInstanceTypeOffset));
       __ cmp(edx, JS_FUNCTION_TYPE);
-      cc_reg_ = equal;
+      true_target()->Branch(equal);
+      false_target()->Jump();
 
     } else if (check->Equals(Heap::object_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       false_target()->Branch(zero);
 
       __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
       __ cmp(edx, Factory::null_value());
       true_target()->Branch(equal);
 
       // It can be an undetectable object.
       __ movzx_b(edx, FieldOperand(ecx, Map::kBitFieldOffset));
       __ and_(edx, 1 << Map::kIsUndetectable);
       __ cmp(edx, 1 << Map::kIsUndetectable);
       false_target()->Branch(equal);
 
       __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
       __ cmp(ecx, FIRST_JS_OBJECT_TYPE);
       false_target()->Branch(less);
       __ cmp(ecx, LAST_JS_OBJECT_TYPE);
-      cc_reg_ = less_equal;
+      true_target()->Branch(less_equal);
+      false_target()->Jump();
 
     } else {
       // Uncommon case: typeof testing against a string literal that is
       // never returned from the typeof operator.
       false_target()->Jump();
-      // TODO(kmilliken) : Can this cause a problem because it is an expression
-      // that exits without a virtual frame in place?
     }
     return;
   }
 
   Condition cc = no_condition;
   bool strict = false;
   switch (op) {
     case Token::EQ_STRICT:
       strict = true;
       // Fall through
@@ skipping 18 matching lines @@
       frame_->InvokeBuiltin(Builtins::IN, CALL_FUNCTION, 2);
       frame_->Push(eax);  // push the result
       return;
     }
     case Token::INSTANCEOF: {
       Load(left);
       Load(right);
       InstanceofStub stub;
       frame_->CallStub(&stub, 2);
       __ test(eax, Operand(eax));
-      cc_reg_ = zero;
+      true_target()->Branch(zero);
+      false_target()->Jump();
       return;
     }
     default:
       UNREACHABLE();
   }
 
   // Optimize for the case where (at least) one of the expressions
   // is a literal small integer.
   if (IsInlineSmi(left->AsLiteral())) {
     Load(right);
     SmiComparison(ReverseCondition(cc), left->AsLiteral()->handle(), strict);
-    return;
-  }
-  if (IsInlineSmi(right->AsLiteral())) {
+  } else if (IsInlineSmi(right->AsLiteral())) {
     Load(left);
     SmiComparison(cc, right->AsLiteral()->handle(), strict);
-    return;
+  } else {
+    Load(left);
+    Load(right);
+    Comparison(cc, strict, true_target(), false_target());
   }
-
-  Load(left);
-  Load(right);
-  Comparison(cc, strict);
 }
 
 
 #ifdef DEBUG
 bool CodeGenerator::HasValidEntryRegisters() {
   return (allocator()->count(eax) == frame()->register_count(eax))
       && (allocator()->count(ebx) == frame()->register_count(ebx))
       && (allocator()->count(ecx) == frame()->register_count(ecx))
       && (allocator()->count(edx) == frame()->register_count(edx))
       && (allocator()->count(edi) == frame()->register_count(edi));
@@ skipping 69 matching lines @@
     Literal* raw_name = property->key()->AsLiteral();
     ASSERT(raw_name != NULL);
     return Handle<String>(String::cast(*raw_name->handle()));
   }
 }
 
 
 void Reference::GetValue(TypeofState typeof_state) {
   ASSERT(!cgen_->in_spilled_code());
   ASSERT(!is_illegal());
-  ASSERT(!cgen_->has_cc());
   MacroAssembler* masm = cgen_->masm();
   switch (type_) {
     case SLOT: {
       Comment cmnt(masm, "[ Load from Slot");
       Slot* slot = expression_->AsVariableProxy()->AsVariable()->slot();
       ASSERT(slot != NULL);
       cgen_->LoadFromSlot(slot, typeof_state);
       break;
     }
 
@@ skipping 132 matching lines @@
       UNREACHABLE();
   }
 }
 
 
 void Reference::TakeValue(TypeofState typeof_state) {
   // For non-constant frame-allocated slots, we invalidate the value in the
   // slot.  For all others, we fall back on GetValue.
   ASSERT(!cgen_->in_spilled_code());
   ASSERT(!is_illegal());
-  ASSERT(!cgen_->has_cc());
   if (type_ != SLOT) {
     GetValue(typeof_state);
     return;
   }
 
   Slot* slot = expression_->AsVariableProxy()->AsVariable()->slot();
   ASSERT(slot != NULL);
   if (slot->type() == Slot::LOOKUP ||
       slot->type() == Slot::CONTEXT ||
       slot->var()->mode() == Variable::CONST) {
     GetValue(typeof_state);
     return;
   }
 
   // Only non-constant, frame-allocated parameters and locals can reach
   // here.
   if (slot->type() == Slot::PARAMETER) {
     cgen_->frame()->TakeParameterAt(slot->index());
   } else {
     ASSERT(slot->type() == Slot::LOCAL);
     cgen_->frame()->TakeLocalAt(slot->index());
   }
 }
 
 
 void Reference::SetValue(InitState init_state) {
   ASSERT(!is_illegal());
-  ASSERT(!cgen_->has_cc());
   MacroAssembler* masm = cgen_->masm();
   VirtualFrame* frame = cgen_->frame();
   switch (type_) {
     case SLOT: {
       Comment cmnt(masm, "[ Store to Slot");
       Slot* slot = expression_->AsVariableProxy()->AsVariable()->slot();
       ASSERT(slot != NULL);
       cgen_->StoreToSlot(slot, init_state);
       break;
     }
@@ skipping 1514 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal