ARM: Don't always go into the runtime system just because a

src/arm/codegen-arm.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 5316 matching lines @@
       // Do multiplication
       __ smull(r3, r2, r1, ip);  // r3 = lower 32 bits of ip*r1.
       // Go slow on overflows (overflow bit is not set).
       __ mov(ip, Operand(r3, ASR, 31));
       __ cmp(ip, Operand(r2));  // no overflow if higher 33 bits are identical
       __ b(ne, &slow);
       // Go slow on zero result to handle -0.
       __ tst(r3, Operand(r3));
       __ mov(r0, Operand(r3), LeaveCC, ne);
       __ Ret(ne);
-      // Slow case.
+      // We need -0 if we were multiplying a negative number with 0 to get 0.
+      // We know one of them was zero.
+      __ add(r2, r0, Operand(r1), SetCC);
+      __ mov(r0, Operand(Smi::FromInt(0)), LeaveCC, pl);

[Lasse Reichstein, 2009/07/01 11:11:14]

Is it more efficient to use r3 instead of Operand(Smi::FromInt(0))? (We should
know that r3 is zero at this point).

[Erik Corry, 2009/07/01 11:31:05]

I'm fairly certain it makes no difference, so I think I'll stick with the less
sneaky version.

+      __ Ret(pl);  // Return Smi 0 if the non-zero one was positive.
+      // Slow case.  We fall through here if we multiplied a negative number
+      // with 0, because that would mean we should produce -0.
       __ bind(&slow);
 
       HandleBinaryOpSlowCases(masm,
                               &not_smi,
                               Builtins::MUL,
                               Token::MUL,
                                 mode_);
       break;
     }
 
@@ skipping 695 matching lines @@
 int CompareStub::MinorKey() {
   // Encode the two parameters in a unique 16 bit value.
   ASSERT(static_cast<unsigned>(cc_) >> 28 < (1 << 15));
   return (static_cast<unsigned>(cc_) >> 27) | (strict_ ? 1 : 0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal