Streamline CodeGenerator::Comparison in the IA32 code generator. When...

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 1288 matching lines @@
   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();
   } else {
     right_side = frame_->Pop();
     left_side = frame_->Pop();
   }
+  ASSERT(cc == less || cc == equal || cc == greater_equal);
+
   // If either side is a constant smi, optimize the comparison.
   bool left_side_constant_smi =
       left_side.is_constant() && left_side.handle()->IsSmi();
   bool right_side_constant_smi =
       right_side.is_constant() && right_side.handle()->IsSmi();
   bool left_side_constant_null =
       left_side.is_constant() && left_side.handle()->IsNull();
   bool right_side_constant_null =
       right_side.is_constant() && right_side.handle()->IsNull();
 
   if (left_side_constant_smi || right_side_constant_smi) {
     if (left_side_constant_smi && right_side_constant_smi) {
       // Trivial case, comparing two constants.
       int left_value = Smi::cast(*left_side.handle())->value();
       int right_value = Smi::cast(*right_side.handle())->value();
-      if (left_value < right_value &&
-          (cc == less || cc == less_equal || cc == not_equal) ||
-          left_value == right_value &&
-          (cc == less_equal || cc == equal || cc == greater_equal) ||
-          left_value > right_value &&
-          (cc == greater || cc == greater_equal || cc == not_equal)) {
-        // The comparison is unconditionally true.
-        dest->Goto(true);
-      } else {
-        // The comparison is unconditionally false.
-        dest->Goto(false);
+      switch (cc) {
+        case less:
+          dest->Goto(left_value < right_value);
+          break;
+        case equal:
+          dest->Goto(left_value == right_value);
+          break;
+        case greater_equal:
+          dest->Goto(left_value >= right_value);
+          break;
+        default:
+          UNREACHABLE();
       }
     } else {  // Only one side is a constant Smi.
       // If left side is a constant Smi, reverse the operands.
       // Since one side is a constant Smi, conversion order does not matter.
       if (left_side_constant_smi) {
         Result temp = left_side;
         left_side = right_side;
         right_side = temp;
         cc = ReverseCondition(cc);
         // This may reintroduce greater or less_equal as the value of cc.
@@ skipping 65 matching lines @@
       __ movzx_b(temp.reg(),
                  FieldOperand(temp.reg(), Map::kBitFieldOffset));
       __ test(temp.reg(), Immediate(1 << Map::kIsUndetectable));
       temp.Unuse();
       operand.Unuse();
       dest->Split(not_zero);
     }
   } else {  // Neither side is a constant Smi or null.
     // If either side is a non-smi constant, skip the smi check.
     bool known_non_smi =
-      left_side.is_constant() && !left_side.handle()->IsSmi() ||
-      right_side.is_constant() && !right_side.handle()->IsSmi();
+        (left_side.is_constant() && !left_side.handle()->IsSmi()) ||
+        (right_side.is_constant() && !right_side.handle()->IsSmi());
     left_side.ToRegister();
     right_side.ToRegister();
     JumpTarget is_smi(this);
     if (!known_non_smi) {
       // Check for the smi case.
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
       __ mov(temp.reg(), left_side.reg());
       __ or_(temp.reg(), Operand(right_side.reg()));
       __ test(temp.reg(), Immediate(kSmiTagMask));
@@ skipping 5381 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal