Improve generated code for non-smi bit operations by...

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 4464 matching lines @@
     }
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SAR:
     case Token::SHL:
     case Token::SHR: {
       FloatingPointHelper::CheckFloatOperands(masm, &call_runtime, ebx);
       FloatingPointHelper::LoadFloatOperands(masm, ecx);
 
-      Label non_int32_operands, non_smi_result, skip_allocation;
-      // Reserve space for converted numbers.
-      __ sub(Operand(esp), Immediate(2 * kPointerSize));
+      Label non_smi_result, skip_allocation, operands_too_large;
 
-      // Check if right operand is int32.
-      __ fist_s(Operand(esp, 1 * kPointerSize));
-      __ fild_s(Operand(esp, 1 * kPointerSize));
+      // Make sure that the operands can be truncated into 64-bit
+      // integers. Otherwise, the fistt instruction will signal an IA
+      // exception which will cause us to overwrite the operand with
+      // zero.
+      __ push(Immediate(0x7fffffff));
+      __ push(Immediate(-1));
+      __ fild_d(Operand(esp, 0));
+      __ add(Operand(esp), Immediate(2 * kPointerSize));
+
+      // Convert the operands to absolute values before comparing
+      // against the limit.
+      __ fld(2);
+      __ fabs();
+      __ fld(2);
+      __ fabs();
+
+      // Do the comparison. If the operands are too large we go
+      // slow-case through the runtime system.
+      __ fucomp(2);
+      __ fnstsw_ax();
+      __ sahf();
+      __ j(above, &operands_too_large);
       __ fucompp();
       __ fnstsw_ax();
       __ sahf();
-      __ j(not_zero, &non_int32_operands);
-      __ j(parity_even, &non_int32_operands);
+      __ j(above, &operands_too_large);
 
-      // Check if left operand is int32.
-      __ fist_s(Operand(esp, 0 * kPointerSize));
-      __ fild_s(Operand(esp, 0 * kPointerSize));
-      __ fucompp();
+      // Reserve space for converted numbers.
+      __ sub(Operand(esp), Immediate(4 * kPointerSize));
+
+      // Convert right operand to int32.
+      Label done_right;
+      __ fnclex();
+      __ fisttp_d(Operand(esp, 2 * kPointerSize));

[Erik Corry, 2009/02/20 16:40:41]

This is an SSE3 instruction :-(.  I guess we can still use it but not in
snapshots and not without checking for SSE3.  See the Exceptions section of the
Intel documentation where it says it throws UD if the SSE3 bit is not set.

       __ fnstsw_ax();
-      __ sahf();
-      __ j(not_zero, &non_int32_operands);
-      __ j(parity_even, &non_int32_operands);
+      __ test(eax, Immediate(1));
+      __ j(zero, &done_right);
+      __ fnclex();
+      __ mov(Operand(esp, 2 * kPointerSize), Immediate(0));
+      __ bind(&done_right);
+
+      // Convert left operand to int32.
+      Label done_left;
+      __ fisttp_d(Operand(esp, 0 * kPointerSize));
+      __ fnstsw_ax();
+      __ test(eax, Immediate(1));
+      __ j(zero, &done_left);
+      __ mov(Operand(esp, 0 * kPointerSize), Immediate(0));
+      __ bind(&done_left);
 
       // Get int32 operands and perform bitop.
       __ pop(eax);
+      __ add(Operand(esp), Immediate(kPointerSize));
       __ pop(ecx);
+      __ add(Operand(esp), Immediate(kPointerSize));
       switch (op_) {
         case Token::BIT_OR:  __ or_(eax, Operand(ecx)); break;
         case Token::BIT_AND: __ and_(eax, Operand(ecx)); break;
         case Token::BIT_XOR: __ xor_(eax, Operand(ecx)); break;
         case Token::SAR: __ sar(eax); break;
         case Token::SHL: __ shl(eax); break;
         case Token::SHR: __ shr(eax); break;
         default: UNREACHABLE();
       }
 
@@ skipping 27 matching lines @@
             __ bind(&skip_allocation);
             break;
           default: UNREACHABLE();
         }
         // Store the result in the HeapNumber and return.
         __ mov(Operand(esp, 1 * kPointerSize), ebx);
         __ fild_s(Operand(esp, 1 * kPointerSize));
         __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
         __ ret(2 * kPointerSize);
       }
-      __ bind(&non_int32_operands);
-      // Restore stacks and operands before calling runtime.
+
+      // Free ST(0) and ST(1) before calling runtime.
+      __ bind(&operands_too_large);
       __ ffree(0);
-      __ add(Operand(esp), Immediate(2 * kPointerSize));
+      __ ffree(1);
 
       // SHR should return uint32 - go to runtime for non-smi/negative result.
       if (op_ == Token::SHR) __ bind(&non_smi_result);
       __ mov(eax, Operand(esp, 1 * kPointerSize));
       __ mov(edx, Operand(esp, 2 * kPointerSize));
       break;
     }
     default: UNREACHABLE(); break;
   }
 
@@ skipping 851 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal