Experimental parser: merge r19949

src/a64/macro-assembler-a64-inl.h

 // 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 328 matching lines @@
                          const Register& rn,
                          const Register& rm) {
   ASSERT(allow_macro_instructions_);
   ASSERT(!rd.IsZero());
   asrv(rd, rn, rm);
 }
 
 
 void MacroAssembler::B(Label* label) {
   b(label);
-  CheckVeneers(false);
+  CheckVeneerPool(false);
 }
 
 
 void MacroAssembler::B(Condition cond, Label* label) {
   ASSERT(allow_macro_instructions_);
   B(label, cond);
 }
 
 
 void MacroAssembler::Bfi(const Register& rd,
@@ skipping 221 matching lines @@
 
 void MacroAssembler::Fcmp(const FPRegister& fn, const FPRegister& fm) {
   ASSERT(allow_macro_instructions_);
   fcmp(fn, fm);
 }
 
 
 void MacroAssembler::Fcmp(const FPRegister& fn, double value) {
   ASSERT(allow_macro_instructions_);
   if (value != 0.0) {
-    FPRegister tmp = AppropriateTempFor(fn);
+    UseScratchRegisterScope temps(this);
+    FPRegister tmp = temps.AcquireSameSizeAs(fn);
     Fmov(tmp, value);
     fcmp(fn, tmp);
   } else {
     fcmp(fn, value);
   }
 }
 
 
 void MacroAssembler::Fcsel(const FPRegister& fd,
                            const FPRegister& fn,
@@ skipping 127 matching lines @@
 
 
 void MacroAssembler::Fmov(FPRegister fd, Register rn) {
   ASSERT(allow_macro_instructions_);
   fmov(fd, rn);
 }
 
 
 void MacroAssembler::Fmov(FPRegister fd, double imm) {
   ASSERT(allow_macro_instructions_);
-  if ((fd.Is64Bits() && IsImmFP64(imm)) ||
-      (fd.Is32Bits() && IsImmFP32(imm)) ||
-      ((imm == 0.0) && (copysign(1.0, imm) == 1.0))) {
-    // These cases can be handled by the Assembler.
+  if (fd.Is32Bits()) {
+    Fmov(fd, static_cast<float>(imm));
+    return;
+  }
+
+  ASSERT(fd.Is64Bits());
+  if (IsImmFP64(imm)) {
     fmov(fd, imm);
+  } else if ((imm == 0.0) && (copysign(1.0, imm) == 1.0)) {
+    fmov(fd, xzr);
   } else {
-    // TODO(all): The Assembler would try to relocate the immediate with
-    // Assembler::ldr(const FPRegister& ft, double imm) but it is not
-    // implemented yet.
-    if (fd.SizeInBits() == kDRegSize) {
-      Mov(Tmp0(), double_to_rawbits(imm));
-      Fmov(fd, Tmp0());
-    } else {
-      ASSERT(fd.SizeInBits() == kSRegSize);
-      Mov(WTmp0(), float_to_rawbits(static_cast<float>(imm)));
-      Fmov(fd, WTmp0());
-    }
+    UseScratchRegisterScope temps(this);
+    Register tmp = temps.AcquireX();
+    // TODO(all): Use Assembler::ldr(const FPRegister& ft, double imm).
+    Mov(tmp, double_to_rawbits(imm));
+    Fmov(fd, tmp);
   }
 }
 
+
+void MacroAssembler::Fmov(FPRegister fd, float imm) {
+  ASSERT(allow_macro_instructions_);
+  if (fd.Is64Bits()) {
+    Fmov(fd, static_cast<double>(imm));
+    return;
+  }
+
+  ASSERT(fd.Is32Bits());
+  if (IsImmFP32(imm)) {
+    fmov(fd, imm);
+  } else if ((imm == 0.0) && (copysign(1.0, imm) == 1.0)) {
+    fmov(fd, wzr);
+  } else {
+    UseScratchRegisterScope temps(this);
+    Register tmp = temps.AcquireW();
+    // TODO(all): Use Assembler::ldr(const FPRegister& ft, float imm).
+    Mov(tmp, float_to_rawbits(imm));
+    Fmov(fd, tmp);
+  }
+}
+
 
 void MacroAssembler::Fmov(Register rd, FPRegister fn) {
   ASSERT(allow_macro_instructions_);
   ASSERT(!rd.IsZero());
   fmov(rd, fn);
 }
 
 
 void MacroAssembler::Fmsub(const FPRegister& fd,
                            const FPRegister& fn,
@@ skipping 238 matching lines @@
   ASSERT(allow_macro_instructions_);
   ASSERT(!rd.IsZero());
   rbit(rd, rn);
 }
 
 
 void MacroAssembler::Ret(const Register& xn) {
   ASSERT(allow_macro_instructions_);
   ASSERT(!xn.IsZero());
   ret(xn);
-  CheckVeneers(false);
+  CheckVeneerPool(false);
 }
 
 
 void MacroAssembler::Rev(const Register& rd, const Register& rn) {
   ASSERT(allow_macro_instructions_);
   ASSERT(!rd.IsZero());
   rev(rd, rn);
 }
 
 
@@ skipping 316 matching lines @@
 void MacroAssembler::JumpIfNotSmi(Register value, Label* not_smi_label) {
   JumpIfSmi(value, NULL, not_smi_label);
 }
 
 
 void MacroAssembler::JumpIfBothSmi(Register value1,
                                    Register value2,
                                    Label* both_smi_label,
                                    Label* not_smi_label) {
   STATIC_ASSERT((kSmiTagSize == 1) && (kSmiTag == 0));
+  UseScratchRegisterScope temps(this);
+  Register tmp = temps.AcquireX();
   // Check if both tag bits are clear.
-  Orr(Tmp0(), value1, value2);
-  JumpIfSmi(Tmp0(), both_smi_label, not_smi_label);
+  Orr(tmp, value1, value2);
+  JumpIfSmi(tmp, both_smi_label, not_smi_label);
 }
 
 
 void MacroAssembler::JumpIfEitherSmi(Register value1,
                                      Register value2,
                                      Label* either_smi_label,
                                      Label* not_smi_label) {
   STATIC_ASSERT((kSmiTagSize == 1) && (kSmiTag == 0));
+  UseScratchRegisterScope temps(this);
+  Register tmp = temps.AcquireX();
   // Check if either tag bit is clear.
-  And(Tmp0(), value1, value2);
-  JumpIfSmi(Tmp0(), either_smi_label, not_smi_label);
+  And(tmp, value1, value2);
+  JumpIfSmi(tmp, either_smi_label, not_smi_label);
 }
 
 
 void MacroAssembler::JumpIfEitherNotSmi(Register value1,
                                         Register value2,
                                         Label* not_smi_label) {
   JumpIfBothSmi(value1, value2, NULL, not_smi_label);
 }
 
 
@@ skipping 52 matching lines @@
   } else if (not_string == NULL) {
     TestAndBranchIfAllClear(type.W(), kIsNotStringMask, string);
   } else {
     TestAndBranchIfAnySet(type.W(), kIsNotStringMask, not_string);
     B(string);
   }
 }
 
 
 void MacroAssembler::Push(Handle<Object> handle) {
-  Mov(Tmp0(), Operand(handle));
-  Push(Tmp0());
+  UseScratchRegisterScope temps(this);
+  Register tmp = temps.AcquireX();
+  Mov(tmp, Operand(handle));
+  Push(tmp);
 }
 
 
 void MacroAssembler::Claim(uint64_t count, uint64_t unit_size) {
   uint64_t size = count * unit_size;
 
   if (size == 0) {
     return;
   }
 
   if (csp.Is(StackPointer())) {
     ASSERT(size % 16 == 0);
   } else {
     BumpSystemStackPointer(size);
   }
 
   Sub(StackPointer(), StackPointer(), size);
 }
 
 
 void MacroAssembler::Claim(const Register& count, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
 
   if (unit_size == 0) {
     return;
   }
 
-  const int shift = CountTrailingZeros(unit_size, kXRegSize);
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits);
   const Operand size(count, LSL, shift);
 
   if (size.IsZero()) {
     return;
   }
 
   if (!csp.Is(StackPointer())) {
     BumpSystemStackPointer(size);
   }
 
   Sub(StackPointer(), StackPointer(), size);
 }
 
 
 void MacroAssembler::ClaimBySMI(const Register& count_smi, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
-  const int shift = CountTrailingZeros(unit_size, kXRegSize) - kSmiShift;
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits) - kSmiShift;
   const Operand size(count_smi,
                      (shift >= 0) ? (LSL) : (LSR),
                      (shift >= 0) ? (shift) : (-shift));
 
   if (size.IsZero()) {
     return;
   }
 
   if (!csp.Is(StackPointer())) {
     BumpSystemStackPointer(size);
@@ skipping 23 matching lines @@
 }
 
 
 void MacroAssembler::Drop(const Register& count, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
 
   if (unit_size == 0) {
     return;
   }
 
-  const int shift = CountTrailingZeros(unit_size, kXRegSize);
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits);
   const Operand size(count, LSL, shift);
 
   if (size.IsZero()) {
     return;
   }
 
   Add(StackPointer(), StackPointer(), size);
 
   if (!csp.Is(StackPointer()) && emit_debug_code()) {
     // It is safe to leave csp where it is when unwinding the JavaScript stack,
     // but if we keep it matching StackPointer, the simulator can detect memory
     // accesses in the now-free part of the stack.
     Mov(csp, StackPointer());
   }
 }
 
 
 void MacroAssembler::DropBySMI(const Register& count_smi, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
-  const int shift = CountTrailingZeros(unit_size, kXRegSize) - kSmiShift;
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits) - kSmiShift;
   const Operand size(count_smi,
                      (shift >= 0) ? (LSL) : (LSR),
                      (shift >= 0) ? (shift) : (-shift));
 
   if (size.IsZero()) {
     return;
   }
 
   Add(StackPointer(), StackPointer(), size);
 
@@ skipping 78 matching lines @@
   // characters are reserved for controlling features of the instrumentation.
   ASSERT(isprint(marker_name[0]) && isprint(marker_name[1]));
 
   InstructionAccurateScope scope(this, 1);
   movn(xzr, (marker_name[1] << 8) | marker_name[0]);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_A64_MACRO_ASSEMBLER_A64_INL_H_