Fix bug in r5123, Comparison(), by unusing results before unconditional jump ...

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 1427 matching lines @@
       break;
   }
   if (answer_object == Heap::undefined_value()) {
     return false;
   }
   frame_->Push(Handle<Object>(answer_object));
   return true;
 }
 
 
-void CodeGenerator::JumpIfBothSmiUsingTypeInfo(Register left,
-                                               Register right,
-                                               TypeInfo left_info,
-                                               TypeInfo right_info,
+void CodeGenerator::JumpIfBothSmiUsingTypeInfo(Result* left,
+                                               Result* right,
                                                JumpTarget* both_smi) {
+  TypeInfo left_info = left->type_info();
+  TypeInfo right_info = right->type_info();
   if (left_info.IsDouble() || left_info.IsString() ||
       right_info.IsDouble() || right_info.IsString()) {
     // We know that left and right are not both smi.  Don't do any tests.
     return;
   }
 
-  if (left.is(right)) {
+  if (left->reg().is(right->reg())) {
     if (!left_info.IsSmi()) {
-      __ test(left, Immediate(kSmiTagMask));
+      __ test(left->reg(), Immediate(kSmiTagMask));
       both_smi->Branch(zero);
     } else {
-      if (FLAG_debug_code) __ AbortIfNotSmi(left);
+      if (FLAG_debug_code) __ AbortIfNotSmi(left->reg());
+      left->Unuse();
+      right->Unuse();
       both_smi->Jump();
     }
   } else if (!left_info.IsSmi()) {
     if (!right_info.IsSmi()) {
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
-      __ mov(temp.reg(), left);
-      __ or_(temp.reg(), Operand(right));
+      __ mov(temp.reg(), left->reg());
+      __ or_(temp.reg(), Operand(right->reg()));
       __ test(temp.reg(), Immediate(kSmiTagMask));
       temp.Unuse();
       both_smi->Branch(zero);
     } else {
-      __ test(left, Immediate(kSmiTagMask));
+      __ test(left->reg(), Immediate(kSmiTagMask));
       both_smi->Branch(zero);
     }
   } else {
-    if (FLAG_debug_code) __ AbortIfNotSmi(left);
+    if (FLAG_debug_code) __ AbortIfNotSmi(left->reg());
     if (!right_info.IsSmi()) {
-      __ test(right, Immediate(kSmiTagMask));
+      __ test(right->reg(), Immediate(kSmiTagMask));
       both_smi->Branch(zero);
     } else {
-      if (FLAG_debug_code) __ AbortIfNotSmi(right);
+      if (FLAG_debug_code) __ AbortIfNotSmi(right->reg());
+      left->Unuse();
+      right->Unuse();
       both_smi->Jump();
     }
   }
 }
 
 
 void CodeGenerator::JumpIfNotBothSmiUsingTypeInfo(Register left,
                                                   Register right,
                                                   Register scratch,
                                                   TypeInfo left_info,
@@ skipping 1276 matching lines @@
       // Here we split control flow to the stub call and inlined cases
       // before finally splitting it to the control destination.  We use
       // a jump target and branching to duplicate the virtual frame at
       // the first split.  We manually handle the off-frame references
       // by reconstituting them on the non-fall-through path.
       JumpTarget is_smi;
       Register left_reg = left_side.reg();
       Register right_reg = right_side.reg();
 
       // In-line check for comparing two smis.
-      JumpIfBothSmiUsingTypeInfo(left_side.reg(), right_side.reg(),
-                                 left_side.type_info(), right_side.type_info(),
-                                 &is_smi);
+      JumpIfBothSmiUsingTypeInfo(&left_side, &right_side, &is_smi);
 
       if (has_valid_frame()) {
         // 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()));
           dest->true_target()->Branch(equal);
         }
 
         // Inlined number comparison:
@@ skipping 11156 matching lines @@
   masm.GetCode(&desc);
   // Call the function from C++.
   return FUNCTION_CAST<MemCopyFunction>(buffer);
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32