Add fast negative checks for symbol equality: If we're comparing...

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 1788 matching lines @@
   bool strict_;
 
   Major MajorKey() { return Compare; }
 
   int MinorKey() {
     // Encode the three parameters in a unique 16 bit value.
     ASSERT(static_cast<int>(cc_) < (1 << 15));
     return (static_cast<int>(cc_) << 1) | (strict_ ? 1 : 0);
   }
 
+  // Branch to the label if the given object isn't a symbol.
+  void BranchIfNonSymbol(MacroAssembler* masm,
+                         Label* label,
+                         Register object,
+                         Register scratch);
+
 #ifdef DEBUG
   void Print() {
     PrintF("CompareStub (cc %d), (strict %s)\n",
            static_cast<int>(cc_),
            strict_ ? "true" : "false");
   }
 #endif
 };
 
 
@@ skipping 5166 matching lines @@
 
       // Check for oddballs: true, false, null, undefined.
       __ cmp(ecx, ODDBALL_TYPE);
       __ j(equal, &return_not_equal);
 
       // Fall through to the general case.
     }
     __ bind(&slow);
   }
 
-  // Save the return address (and get it off the stack).
+  // Push arguments below the return address.
   __ pop(ecx);
-
-  // Push arguments.
   __ push(eax);
   __ push(edx);
   __ push(ecx);
 
   // Inlined floating point compare.
   // Call builtin if operands are not floating point or smi.
-  FloatingPointHelper::CheckFloatOperands(masm, &call_builtin, ebx);
+  Label check_for_symbols;
+  FloatingPointHelper::CheckFloatOperands(masm, &check_for_symbols, ebx);
   FloatingPointHelper::LoadFloatOperands(masm, ecx);
   __ FCmp();
 
   // Jump to builtin for NaN.
   __ j(parity_even, &call_builtin, not_taken);
 
   // TODO(1243847): Use cmov below once CpuFeatures are properly hooked up.
   Label below_lbl, above_lbl;
   // use edx, eax to convert unsigned to signed comparison
   __ j(below, &below_lbl, not_taken);
   __ j(above, &above_lbl, not_taken);
 
   __ xor_(eax, Operand(eax));  // equal
   __ ret(2 * kPointerSize);
 
   __ bind(&below_lbl);
   __ mov(eax, -1);
   __ ret(2 * kPointerSize);
 
   __ bind(&above_lbl);
   __ mov(eax, 1);
   __ ret(2 * kPointerSize);  // eax, edx were pushed
 
+  // Fast negative check for symbol-to-symbol equality.
+  __ bind(&check_for_symbols);
+  if (cc_ == equal) {
+    BranchIfNonSymbol(masm, &call_builtin, eax, ecx);
+    BranchIfNonSymbol(masm, &call_builtin, edx, ecx);
+
+    // We've already checked for object identity, so if both operands
+    // are symbols they aren't equal. Register eax already holds a
+    // non-zero value, which indicates not equal, so just return.
+    __ ret(2 * kPointerSize);
+  }
+
   __ bind(&call_builtin);
   // must swap argument order
   __ pop(ecx);
   __ pop(edx);
   __ pop(eax);
   __ push(edx);
   __ push(eax);
 
   // Figure out which native to call and setup the arguments.
   Builtins::JavaScript builtin;
@@ skipping 13 matching lines @@
 
   // Restore return address on the stack.
   __ push(ecx);
 
   // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ InvokeBuiltin(builtin, JUMP_FUNCTION);
 }
 
 
+void CompareStub::BranchIfNonSymbol(MacroAssembler* masm,
+                                    Label* label,
+                                    Register object,
+                                    Register scratch) {
+  __ test(object, Immediate(kSmiTagMask));
+  __ j(zero, label);
+  __ mov(scratch, FieldOperand(object, HeapObject::kMapOffset));
+  __ movzx_b(scratch, FieldOperand(scratch, Map::kInstanceTypeOffset));
+  __ and_(scratch, kIsSymbolMask | kIsNotStringMask);
+  __ cmp(scratch, kSymbolTag | kStringTag);
+  __ j(not_equal, label);
+}
+
+
 void StackCheckStub::Generate(MacroAssembler* masm) {
   // Because builtins always remove the receiver from the stack, we
   // have to fake one to avoid underflowing the stack. The receiver
   // must be inserted below the return address on the stack so we
   // temporarily store that in a register.
   __ pop(eax);
   __ push(Immediate(Smi::FromInt(0)));
   __ push(eax);
 
   // Do tail-call to runtime routine.
@@ skipping 410 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal