Computes Boolean AND and OR without spilling frames.

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 389 matching lines @@
 // 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'.
 void CodeGenerator::LoadCondition(Expression* x,
                                   TypeofState typeof_state,
                                   JumpTarget* true_target,
                                   JumpTarget* false_target,
                                   bool force_cc) {
   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()) {
     // 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());
+  ASSERT(!has_valid_frame() ||
+         (has_cc() && frame_->height() == original_height) ||
+         (!has_cc() && 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);
@@ skipping 30 matching lines @@
     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());
     frame_->Push(&temp);
@@ skipping 113 matching lines @@
 
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Pop the top of stack and
 // convert it to a boolean in the condition code register or jump to
 // 'false_target'/'true_target' as appropriate.
 void CodeGenerator::ToBoolean(JumpTarget* true_target,
                               JumpTarget* false_target) {
   Comment cmnt(masm_, "[ ToBoolean");
 
   // The value to convert should be popped from the stack.
-  frame_->EmitPop(eax);
-
+  Result value = frame_->Pop();
+  value.ToRegister();
   // Fast case checks.
 
   // 'false' => false.
-  __ cmp(eax, Factory::false_value());
+  __ cmp(value.reg(), Factory::false_value());
   false_target->Branch(equal);
 
   // 'true' => true.
-  __ cmp(eax, Factory::true_value());
+  __ cmp(value.reg(), Factory::true_value());
   true_target->Branch(equal);
 
   // 'undefined' => false.
-  __ cmp(eax, Factory::undefined_value());
+  __ cmp(value.reg(), Factory::undefined_value());
   false_target->Branch(equal);
 
   // Smi => false iff zero.
   ASSERT(kSmiTag == 0);
-  __ test(eax, Operand(eax));
+  __ test(value.reg(), Operand(value.reg()));
   false_target->Branch(zero);
-  __ test(eax, Immediate(kSmiTagMask));
+  __ test(value.reg(), Immediate(kSmiTagMask));
   true_target->Branch(zero);
 
   // Call the stub for all other cases.
-  frame_->EmitPush(eax);  // Undo the pop(eax) from above.
+  frame_->Push(&value);  // Undo the Pop() from above.
   ToBooleanStub stub;
   frame_->CallStub(&stub, 1);
   // Convert the result (eax) to condition code.
+  Result temp = allocator_->Allocate(eax);
+  ASSERT(temp.is_valid());
   __ test(eax, Operand(eax));
 
   ASSERT(not_equal == not_zero);
   cc_reg_ = not_equal;
 }
 
 
 class FloatingPointHelper : public AllStatic {
  public:
   // Code pattern for loading floating point values. Input values must
@@ skipping 3366 matching lines @@
   }
 
   // Postfix: Discard the new value and use the old.
   if (is_postfix) {
     frame_->Drop();
   }
 }
 
 
 void CodeGenerator::VisitBinaryOperation(BinaryOperation* node) {
-  VirtualFrame::SpilledScope spilled_scope(this);
   // Note that due to an optimization in comparison operations (typeof
   // compared to a string literal), we can evaluate a binary expression such
   // as AND or OR and not leave a value on the frame or in the cc register.
   Comment cmnt(masm_, "[ BinaryOperation");
   Token::Value op = node->op();
 
   // According to ECMA-262 section 11.11, page 58, the binary logical
   // operators must yield the result of one of the two expressions
   // before any ToBoolean() conversions. This means that the value
   // produced by a && or || operator is not necessarily a boolean.
 
   // NOTE: If the left hand side produces a materialized value (not in
   // 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);
-    LoadConditionAndSpill(node->left(), NOT_INSIDE_TYPEOF,
-                          &is_true, false_target(), false);
+    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() || is_true.is_linked()) {
+      if (is_true.is_linked()) {
+        is_true.Bind();
+      }
+      if (has_valid_frame()) {
         // Evaluate right side expression.
-        is_true.Bind();
-        LoadConditionAndSpill(node->right(), NOT_INSIDE_TYPEOF,
-                              true_target(), false_target(), false);
+        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.
-      __ mov(eax, frame_->Top());
-      frame_->EmitPush(eax);
+      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();
-      LoadAndSpill(node->right());
+      Load(node->right());
 
       // 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);
+    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() || is_false.is_linked()) {
+      if (is_false.is_linked()) {
         // Evaluate right side expression.
         is_false.Bind();
-        LoadConditionAndSpill(node->right(), NOT_INSIDE_TYPEOF,
-                              true_target(), false_target(), false);
       }
-
+      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.
-      __ mov(eax, frame_->Top());
-      frame_->EmitPush(eax);
+      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();
-      LoadAndSpill(node->right());
+      Load(node->right());
 
       // Exit (always with a materialized value).
       exit.Bind();
     }
 
   } else {
+    VirtualFrame::SpilledScope spilled_scope(this);
     // NOTE: The code below assumes that the slow cases (calls to runtime)
     // never return a constant/immutable object.
     OverwriteMode overwrite_mode = NO_OVERWRITE;
     if (node->left()->AsBinaryOperation() != NULL &&
         node->left()->AsBinaryOperation()->ResultOverwriteAllowed()) {
       overwrite_mode = OVERWRITE_LEFT;
     } else if (node->right()->AsBinaryOperation() != NULL &&
                node->right()->AsBinaryOperation()->ResultOverwriteAllowed()) {
       overwrite_mode = OVERWRITE_RIGHT;
     }
@@ skipping 1881 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal