Mark all loop conditions.

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 2454 matching lines @@
       // the first split.  We manually handle the off-frame references
       // by reconstituting them on the non-fall-through path.
 
       if (left_side.is_smi()) {
         if (FLAG_debug_code) __ AbortIfNotSmi(left_side.reg());
       } else {
         JumpTarget is_smi;
         __ test(left_side.reg(), Immediate(kSmiTagMask));
         is_smi.Branch(zero, taken);
 
-        bool is_for_loop_compare = (node->AsCompareOperation() != NULL)
-            && node->AsCompareOperation()->is_for_loop_condition();
-        if (!is_for_loop_compare
-            && CpuFeatures::IsSupported(SSE2)
-            && right_val->IsSmi()) {
+        bool is_loop_condition = (node->AsExpression() != NULL) &&

[fschneider, 2010/03/23 13:19:38]

I think we should change CodeGenerator::Comparison to take an Expression* node
as argument.

+            node->AsExpression()->is_loop_condition();
+        if (!is_loop_condition &&
+            CpuFeatures::IsSupported(SSE2) &&
+            right_val->IsSmi()) {
           // Right side is a constant smi and left side has been checked
           // not to be a smi.
           CpuFeatures::Scope use_sse2(SSE2);
           JumpTarget not_number;
           __ cmp(FieldOperand(left_reg, HeapObject::kMapOffset),
                  Immediate(Factory::heap_number_map()));
           not_number.Branch(not_equal, &left_side);
           __ movdbl(xmm1,
                     FieldOperand(left_reg, HeapNumber::kValueOffset));
           int value = Smi::cast(*right_val)->value();
@@ skipping 223 matching lines @@
 
     // Inline number comparison handling any combination of smi's and heap
     // numbers if:
     //   code is in a loop
     //   the compare operation is different from equal
     //   compare is not a for-loop comparison
     // The reason for excluding equal is that it will most likely be done
     // with smi's (not heap numbers) and the code to comparing smi's is inlined
     // separately. The same reason applies for for-loop comparison which will
     // also most likely be smi comparisons.
-    bool is_for_loop_compare = (node->AsCompareOperation() != NULL)
-        && node->AsCompareOperation()->is_for_loop_condition();
-    bool inline_number_compare = loop_nesting() > 0
-                                 && cc != equal
-                                 && !is_for_loop_compare;
+    bool is_loop_condition = (node->AsExpression() != NULL)
+        && node->AsExpression()->is_loop_condition();
+    bool inline_number_compare =
+        loop_nesting() > 0 && cc != equal && !is_loop_condition;
 
     // Left and right needed in registers for the following code.
     left_side.ToRegister();
     right_side.ToRegister();
 
     if (known_non_smi) {
       // Inline the equality check if both operands can't be a NaN. If both
       // objects are the same they are equal.
       if (nan_info == kCantBothBeNaN && cc == equal) {
         __ cmp(left_side.reg(), Operand(right_side.reg()));
@@ skipping 9747 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal