[v8-dev] ARM: safepoints frame optimization

src/arm/macro-assembler-arm.cc

 // Copyright 2012 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 606 matching lines @@
   ldm(ia_w, sp, (marker_reg.is_valid() ? marker_reg.bit() : 0) |
                 cp.bit() |
                 (FLAG_enable_ool_constant_pool ? pp.bit() : 0) |
                 fp.bit() |
                 lr.bit());
 }
 
 
 // Push and pop all registers that can hold pointers.
 void MacroAssembler::PushSafepointRegisters() {
-  // Safepoints expect a block of contiguous register values starting with r0:
-  ASSERT(((1 << kNumSafepointSavedRegisters) - 1) == kSafepointSavedRegisters);
-  // Safepoints expect a block of kNumSafepointRegisters values on the
-  // stack, so adjust the stack for unsaved registers.
-  const int num_unsaved = kNumSafepointRegisters - kNumSafepointSavedRegisters;
-  ASSERT(num_unsaved >= 0);
-  sub(sp, sp, Operand(num_unsaved * kPointerSize));
-  stm(db_w, sp, kSafepointSavedRegisters);
+  // This function must be called from LCodeGen::GenerateCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT(registers_mask() != kRegListEmpty);
+  stm(db_w, sp, registers_mask());
 }
 
 
 void MacroAssembler::PopSafepointRegisters() {
-  const int num_unsaved = kNumSafepointRegisters - kNumSafepointSavedRegisters;
-  ldm(ia_w, sp, kSafepointSavedRegisters);
-  add(sp, sp, Operand(num_unsaved * kPointerSize));
+  // This function must be called from LCodeGen::GenerateCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT(registers_mask() != kRegListEmpty);
+  ldm(ia_w, sp, registers_mask());
 }
 
 
 void MacroAssembler::PushSafepointRegistersAndDoubles() {
-  // Number of d-regs not known at snapshot time.
-  ASSERT(!Serializer::enabled());
   PushSafepointRegisters();
-  // Only save allocatable registers.
-  ASSERT(kScratchDoubleReg.is(d15) && kDoubleRegZero.is(d14));
-  ASSERT(DwVfpRegister::NumReservedRegisters() == 2);
-  if (CpuFeatures::IsSupported(VFP32DREGS)) {
-    vstm(db_w, sp, d16, d31);
+  // The vstm instruction can only save up to 16 doubles. So we save all the
+  // doubles registers with up to 2 instructions.
+  RegList high_mask = double_registers_mask() & 0xffff0000;
+  if (high_mask != 0) {
+    for (int i = LowDwVfpRegister::kMaxNumLowRegisters;
+         i < DoubleRegister::NumRegisters();
+         i++) {
+      if ((high_mask & (1 << i)) != 0) {
+        int last = i + CompilerIntrinsics::CountSetBits(high_mask) - 1;
+        // When double_registers_mask has been initialized, we ensured that
+        // there is no holes between the first and the last high registers.
+        ASSERT(((((1 << last) - 1) | (1 << last)) & ~((1 << i) - 1)) ==
+               high_mask);
+        vstm(db_w, sp, DwVfpRegister::from_code(i),
+             DwVfpRegister::from_code(last));
+        break;
+      }
+    }
   }
-  vstm(db_w, sp, d0, d13);
+  RegList low_mask = double_registers_mask() & 0xffff;
+  if (low_mask != 0) {
+    for (int i = 0; i < LowDwVfpRegister::kMaxNumLowRegisters; i++) {
+      if ((low_mask & (1 << i)) != 0) {
+        int last = i + CompilerIntrinsics::CountSetBits(low_mask) - 1;
+        // When double_registers_mask has been initialized, we ensured that
+        // there is no holes between the first and the last low registers.
+        ASSERT(((((1 << last) - 1) | (1 << last)) & ~((1 << i) - 1)) ==
+               low_mask);
+        vstm(db_w, sp, LowDwVfpRegister::from_code(i),
+             LowDwVfpRegister::from_code(last));
+        break;
+      }
+    }
+  }
 }
 
 
 void MacroAssembler::PopSafepointRegistersAndDoubles() {
-  // Number of d-regs not known at snapshot time.
-  ASSERT(!Serializer::enabled());
-  // Only save allocatable registers.
-  ASSERT(kScratchDoubleReg.is(d15) && kDoubleRegZero.is(d14));
-  ASSERT(DwVfpRegister::NumReservedRegisters() == 2);
-  vldm(ia_w, sp, d0, d13);
-  if (CpuFeatures::IsSupported(VFP32DREGS)) {
-    vldm(ia_w, sp, d16, d31);
+  // The vldm instruction can only restore up to 16 doubles. So we save all the
+  // doubles registers with up to 2 instructions.
+  RegList low_mask = double_registers_mask() & 0xffff;
+  if (low_mask != 0) {
+    for (int i = 0; i < LowDwVfpRegister::kMaxNumLowRegisters; i++) {
+      if ((low_mask & (1 << i)) != 0) {
+        int last = i + CompilerIntrinsics::CountSetBits(low_mask) - 1;
+        // When double_registers_mask has been initialized, we ensured that
+        // there is no holes between the first and the last low registers.
+        ASSERT(((((1 << last) - 1) | (1 << last)) & ~((1 << i) - 1)) ==
+               low_mask);
+        vldm(ia_w, sp, LowDwVfpRegister::from_code(i),
+             LowDwVfpRegister::from_code(last));
+        break;
+      }
+    }
+  }
+  RegList high_mask = double_registers_mask() & 0xffff0000;
+  if (high_mask != 0) {
+    for (int i = LowDwVfpRegister::kMaxNumLowRegisters;
+         i < DoubleRegister::NumRegisters();
+         i++) {
+      if ((high_mask & (1 << i)) != 0) {
+        int last = i + CompilerIntrinsics::CountSetBits(high_mask) - 1;
+        // When double_registers_mask has been initialized, we ensured that
+        // there is no holes between the first and the last high registers.
+        ASSERT(((((1 << last) - 1) | (1 << last)) & ~((1 << i) - 1)) ==
+               high_mask);
+        vldm(ia_w, sp, DwVfpRegister::from_code(i),
+             DwVfpRegister::from_code(last));
+        break;
+      }
+    }
   }
   PopSafepointRegisters();
 }
 
 void MacroAssembler::StoreToSafepointRegistersAndDoublesSlot(Register src,
                                                              Register dst) {
+  // This function must be called from LCodeGen::GenerateCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT((registers_mask() & dst.bit()) != kRegListEmpty);
   str(src, SafepointRegistersAndDoublesSlot(dst));
 }
 
 
 void MacroAssembler::StoreToSafepointRegisterSlot(Register src, Register dst) {
+  // This function must be called from LCodeGen::GenerateCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT((registers_mask() & dst.bit()) != kRegListEmpty);
   str(src, SafepointRegisterSlot(dst));
 }
 
 
 void MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) {
+  // This function must be called from LCodeGen::GenerateCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT((registers_mask() & dst.bit()) != kRegListEmpty);
   ldr(dst, SafepointRegisterSlot(src));
 }
 
 
 int MacroAssembler::SafepointRegisterStackIndex(int reg_code) {
+  // This function must be called from LCodeGen::GenerateCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT((registers_mask() & (1 << reg_code)) != kRegListEmpty);
   // The registers are pushed starting with the highest encoding,
   // which means that lowest encodings are closest to the stack pointer.
   ASSERT(reg_code >= 0 && reg_code < kNumSafepointRegisters);
-  return reg_code;
+  ASSERT((registers_mask() & (1 << reg_code)) != 0);
+  // Only count registers below reg_code.
+  return
+     CompilerIntrinsics::CountSetBits(registers_mask() & ((1 << reg_code) - 1));
 }
 
 
 MemOperand MacroAssembler::SafepointRegisterSlot(Register reg) {
   return MemOperand(sp, SafepointRegisterStackIndex(reg.code()) * kPointerSize);
 }
 
 
 MemOperand MacroAssembler::SafepointRegistersAndDoublesSlot(Register reg) {
-  // Number of d-regs not known at snapshot time.
-  ASSERT(!Serializer::enabled());
   // General purpose registers are pushed last on the stack.
-  int doubles_size = DwVfpRegister::NumAllocatableRegisters() * kDoubleSize;
+  int doubles_size =
+      CompilerIntrinsics::CountSetBits(double_registers_mask()) * kDoubleSize;
   int register_offset = SafepointRegisterStackIndex(reg.code()) * kPointerSize;
   return MemOperand(sp, doubles_size + register_offset);
 }
 
 
 void MacroAssembler::Ldrd(Register dst1, Register dst2,
                           const MemOperand& src, Condition cond) {
   ASSERT(src.rm().is(no_reg));
   ASSERT(!dst1.is(lr));  // r14.
 
@@ skipping 3331 matching lines @@
   if (divisor < 0 && ms.multiplier() > 0) {
     sub(result, result, Operand(dividend));
   }
   if (ms.shift() > 0) mov(result, Operand(result, ASR, ms.shift()));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM