[x64] add Absps/d and Negps/d macro

src/x64/macro-assembler-x64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
@@ skipping 2956 matching lines @@
 void MacroAssembler::Ucomisd(XMMRegister src1, const Operand& src2) {
   if (CpuFeatures::IsSupported(AVX)) {
     CpuFeatureScope scope(this, AVX);
     vucomisd(src1, src2);
   } else {
     ucomisd(src1, src2);
   }
 }
 
 
+// ----------------------------------------------------------------------------
+
+void MacroAssembler::Absps(XMMRegister dst) {
+  static const struct V8_ALIGNED(16) {
+    uint32_t a;
+    uint32_t b;
+    uint32_t c;
+    uint32_t d;
+  } float_absolute_constant = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
+  Set(kScratchRegister, reinterpret_cast<intptr_t>(&float_absolute_constant));

[Benedikt Meurer, 2016/07/18 04:47:52]

Can we somehow put this somewhere near the roots array so we can use the
ExternalOperand mechanism to avoid this load?

Also can you add Abspd and Negpd versions as well?

+  Andps(dst, Operand(kScratchRegister, 0));
+}
+
+
+void MacroAssembler::Negps(XMMRegister dst) {
+  static const struct V8_ALIGNED(16) {
+    uint32_t a;
+    uint32_t b;
+    uint32_t c;
+    uint32_t d;
+  } float_negate_constant = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
+  Set(kScratchRegister, reinterpret_cast<intptr_t>(&float_negate_constant));
+  Xorps(dst, Operand(kScratchRegister, 0));

[bbudge, 2016/07/18 14:08:09]

It seems like we could avoid the memory access with AVX:

vpxor kScratch, kScratch, kScratch
vsubps dst, kScratch, dst

Is there a reason we can't use 0 - dst?

A similar trick can be done with three instructions for SSE.

+}
+
+
 void MacroAssembler::Cmp(Register dst, Handle<Object> source) {
   AllowDeferredHandleDereference smi_check;
   if (source->IsSmi()) {
     Cmp(dst, Smi::cast(*source));
   } else {
     MoveHeapObject(kScratchRegister, source);
     cmpp(dst, kScratchRegister);
   }
 }
 
@@ skipping 2789 matching lines @@
   movl(rax, dividend);
   shrl(rax, Immediate(31));
   addl(rdx, rax);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64