A64: Implement Smi support in MathAbs

src/a64/macro-assembler-a64.cc

 // Copyright 2013 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 504 matching lines @@
     // Encodable in one load/store instruction.
     LoadStore(rt, addr, op);
   }
 }
 
 
 // Pseudo-instructions.
 
 
 void MacroAssembler::Abs(const Register& rd, const Register& rm,
-                         Label * is_not_representable,
-                         Label * is_representable) {
+                         Label* is_not_representable,
+                         Label* is_representable) {
   ASSERT(allow_macro_instructions_);
   ASSERT(AreSameSizeAndType(rd, rm));
 
   Cmp(rm, 1);
   Cneg(rd, rm, lt);
 
-  // If the comparison set the v flag, the input was the smallest value
+  // If the comparison sets the v flag, the input was the smallest value
   // representable by rm, and the mathematical result of abs(rm) is not
   // representable using two's complement.
   if ((is_not_representable != NULL) && (is_representable != NULL)) {
     B(is_not_representable, vs);
     B(is_representable);
   } else if (is_not_representable != NULL) {
     B(is_not_representable, vs);
   } else if (is_representable != NULL) {
     B(is_representable, vc);
   }
@@ skipping 574 matching lines @@
   // Get the code object and state.  Clear the context and frame pointer (0 was
   // saved in the handler).
   Register object = scratch1;
   Register state = scratch2;
   Pop(object, state, cp, fp);
 
   JumpToHandlerEntry(value, object, state, scratch3, scratch4);
 }
 
 
-void MacroAssembler::SmiAbs(Register smi, Register scratch, Label *slow) {
-  // TODO(all): There is another possible implementation of this function
-  // which would consist of:
-  //   * Comparing the smi with 0.
-  //   * Performing a conditional negate (cneg).
-  //   * Testing if the result is still negative.
-  //
-  // This other implementation uses 1 more instruction but uses one of the new
-  // A64 conditional instruction and doesn't use shifted registers.
-  //
-  // This two versions should be profiled on real hardware as we have no idea
-  // which one will be the fastest.
-  ASSERT(!AreAliased(smi, scratch));
-
-  STATIC_ASSERT(kSmiTag == 0);
-  STATIC_ASSERT(kSmiShift == 32);
-
-  // Do bitwise not or do nothing depending on the sign of the argument.
-  __ Eor(scratch, smi, Operand(smi, ASR, kXRegSize - 1));
-  // Add 1 or do nothing depending on the sign of the argument.
-  __ Adds(smi, scratch, Operand(smi, LSR, kXRegSize - 1));
-
-  // If the result is still negative, go to the slow case.
-  // This only happens for the most negative smi.
-  __ B(mi, slow);
+void MacroAssembler::SmiAbs(const Register& smi, Label* slow) {
+  ASSERT(smi.Is64Bits());
+  Abs(smi, smi, slow);
 }
 
 
 void MacroAssembler::AssertSmi(Register object, BailoutReason reason) {
   if (emit_debug_code()) {
     STATIC_ASSERT(kSmiTag == 0);
     Tst(object, kSmiTagMask);
     Check(eq, reason);
   }
 }
@@ skipping 3549 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64