IA32: Avoid going into stubs or runtime code for bitops even if the...

src/ia32/macro-assembler-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 359 matching lines @@
   bind(&ok);
 }
 
 
 void MacroAssembler::AbortIfNotSmi(Register object) {
   test(object, Immediate(kSmiTagMask));
   Assert(equal, "Operand not a smi");
 }
 
 
+void MacroAssembler::AbortIfSmi(Register object) {
+  test(object, Immediate(kSmiTagMask));
+  Assert(not_equal, "Operand a smi");
+}
+
+
 void MacroAssembler::EnterFrame(StackFrame::Type type) {
   push(ebp);
   mov(ebp, Operand(esp));
   push(esi);
   push(Immediate(Smi::FromInt(type)));
   push(Immediate(CodeObject()));
   if (FLAG_debug_code) {
     cmp(Operand(esp, 0), Immediate(Factory::undefined_value()));
     Check(not_equal, "code object not properly patched");
   }
@@ skipping 1100 matching lines @@
 
   push(eax);
   push(Immediate(p0));
   push(Immediate(reinterpret_cast<intptr_t>(Smi::FromInt(p1 - p0))));
   CallRuntime(Runtime::kAbort, 2);
   // will not return here
   int3();
 }
 
 
+void MacroAssembler::JumpIfNotNumber(Register reg,
+                                     TypeInfo info,
+                                     Label* on_not_number) {
+  if (FLAG_debug_code) AbortIfSmi(reg);
+  if (!info.IsNumber()) {
+    cmp(FieldOperand(reg, HeapObject::kMapOffset),
+        Factory::heap_number_map());
+    j(not_equal, on_not_number);
+  }
+}
+
+
+void MacroAssembler::JumpIfNotInt32(Register reg,
+                                    Register scratch,
+                                    TypeInfo info,
+                                    Label* on_not_int32) {
+  if (FLAG_debug_code) {
+    AbortIfSmi(reg);
+    AbortIfNotNumber(reg);
+  }
+  const uint32_t non_smi_exponent =
+      (HeapNumber::kExponentBias + 30) << HeapNumber::kExponentShift;
+  if (!info.IsInteger32()) {
+    bool push_pop = scratch.is(no_reg);
+    if (push_pop) {
+      push(reg);
+      scratch = reg;
+    }
+    mov(scratch, FieldOperand(reg, HeapNumber::kExponentOffset));
+    and_(scratch, HeapNumber::kExponentMask);
+    cmp(scratch, non_smi_exponent);
+    if (push_pop) {
+      pop(reg);
+    }
+    j(greater, on_not_int32);

[Lasse Reichstein, 2010/08/06 08:20:12]

Is this faster than using SSE2 cvttsd2si and checking against 0x8000000? Even if
it is, using cvttsd2si would also give the 32-bit number as a result
immediately, instead of first doing this test and then converting afterwards, as
it seemed was the typical use of this function.
E.g., I'm suggesting a: 
 NumberToInt32(Register dst, Register src, TypeInfo info, Label* on_not_int32)

[Erik Corry, 2010/08/09 13:13:49]

Done.

+  }
+}
+
+
 void MacroAssembler::JumpIfInstanceTypeIsNotSequentialAscii(
     Register instance_type,
     Register scratch,
     Label* failure) {
   if (!scratch.is(instance_type)) {
     mov(scratch, instance_type);
   }
   and_(scratch,
        kIsNotStringMask | kStringRepresentationMask | kStringEncodingMask);
   cmp(scratch, kStringTag | kSeqStringTag | kAsciiStringTag);
@@ skipping 88 matching lines @@
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32