Experimental: processor flags are not preserved across CFG edges...

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 1251 matching lines @@
     right_side.ToRegister(eax);
   } else {
     frame_->Spill(eax);  // Can be multiply referenced, even now.
     frame_->Spill(edx);
     __ xchg(eax, edx);
     // If left_side and right_side become real (non-dummy) arguments
     // to CallStub, they need to be swapped in this case.
   }
   CompareStub stub(cc, strict);
   Result answer = frame_->CallStub(&stub, &right_side, &left_side, 0);
+  ASSERT(answer.is_register() && answer.reg().is_byte_register());
+  frame_->Spill(answer.reg());
   if (cc == equal) {
     __ test(answer.reg(), Operand(answer.reg()));
   } else {
     __ cmp(answer.reg(), 0);
   }
-  answer.Unuse();
+  __ setcc(cc, answer.reg());
+  __ and_(Operand(answer.reg()), Immediate(1));
   // The expected frame at JumpTarget "done" is bound to the current frame.
   // This current frame is spilled, due to the call to CallStub.
   // It would be better if the fast SMI case controlled the expected frame.
-  done.Jump();
+  done.Jump(&answer);
 
   is_smi.Bind(&left_side, &right_side);
+  left_side.ToRegister();
+  right_side.ToRegister();
+  // Find a byte register for the flag value.
+  if (!left_side.reg().is_byte_register() &&
+      !right_side.reg().is_byte_register()) {
+    // If we allocate a register here, it should be a byte register
+    // because there is only one non-reserved register on IA32 that
+    // does not have a byte part (namely edi) and it must be left_side
+    // (and right_side).
+    answer = allocator_->Allocate();
+    ASSERT(answer.is_register() && answer.reg().is_byte_register());
+  } else {
+    answer = left_side.reg().is_byte_register() ? left_side : right_side;
+    frame_->Spill(answer.reg());
+  }
   __ cmp(left_side.reg(), Operand(right_side.reg()));
   right_side.Unuse();
   left_side.Unuse();
-  // Fall through to |done|.
+  __ setcc(cc, answer.reg());
+  __ and_(Operand(answer.reg()), Immediate(1));
 
-  done.Bind();
-  cc_reg_ = cc;
+  done.Bind(&answer);
+  answer.ToRegister();
+  __ test(answer.reg(), Operand(answer.reg()));
+  cc_reg_ = not_zero;
 }
 
 
 class DeferredSmiComparison: public DeferredCode {
  public:
   DeferredSmiComparison(CodeGenerator* generator,
                         Condition cc,
                         bool strict,
                         int int_value) :
       DeferredCode(generator),
@@ skipping 16 matching lines @@
   CompareStub stub(cc_, strict_);
   Result argument(cgen);
   enter()->Bind(&argument);
 
   // Setup parameters and call stub.
   argument.ToRegister(edx);
   Result value = cgen->allocator()->Allocate(eax);
   ASSERT(value.is_valid());
   __ Set(value.reg(), Immediate(Smi::FromInt(int_value_)));
   Result result = cgen->frame()->CallStub(&stub, &argument, &value, 0);
-  ASSERT(result.is_register());
+  ASSERT(result.is_register() && result.reg().is_byte_register());
+  cgen->frame()->Spill(result.reg());
   __ cmp(result.reg(), 0);
-  result.Unuse();
-  // The actual result is returned in the flags.
-  exit()->Jump();
+  __ setcc(cc_, result.reg());
+  __ and_(Operand(result.reg()), Immediate(1));
+  exit()->Jump(&result);
 }
 
 
 void CodeGenerator::SmiComparison(Condition cc,
                                   Handle<Object> value,
                                   bool strict) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   int int_value = Smi::cast(*value)->value();
   ASSERT(is_intn(int_value, kMaxSmiInlinedBits));
 
   DeferredSmiComparison* deferred =
       new DeferredSmiComparison(this, cc, strict, int_value);
 
   Result comparee = frame_->Pop();
   comparee.ToRegister();
   __ test(comparee.reg(), Immediate(kSmiTagMask));
   deferred->enter()->Branch(not_zero, &comparee, not_taken);
+  // Find a byte register to hold the flag value.  If the comparee is
+  // a byte register we can use it, otherwise allocating will give us
+  // one since there is only one non-reserved IA32 register that does
+  // not have a byte part (namely edi).
+  Result flag(this);
+  if (comparee.reg().is_byte_register()) {
+    flag = comparee;
+    frame_->Spill(flag.reg());
+  } else {
+    flag = allocator_->Allocate();
+    ASSERT(flag.is_register() && flag.reg().is_byte_register());
+  }
   // Test smi equality and comparison by signed int comparison.
   __ cmp(Operand(comparee.reg()), Immediate(value));
   comparee.Unuse();
-  deferred->exit()->Bind();
-  cc_reg_ = cc;
+  __ 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;
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
@@ skipping 2217 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));
-  JumpTarget answer(this);
+  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);
-  answer.Branch(not_equal, not_taken);
+  __ j(not_equal, &answer, not_taken);
   // 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);
-  answer.Bind();
+  __ bind(&answer);
   cc_reg_ = equal;
 }
 
 
 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.
@@ skipping 2486 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal