ARM64: push/pop registers in stubs for safepoints

src/arm64/lithium-codegen-arm64.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 359 matching lines @@
 
   class PushSafepointRegistersScope BASE_EMBEDDED {
    public:
     PushSafepointRegistersScope(LCodeGen* codegen,
                                 Safepoint::Kind kind)
         : codegen_(codegen) {
       ASSERT(codegen_->info()->is_calling());
       ASSERT(codegen_->expected_safepoint_kind_ == Safepoint::kSimple);
       codegen_->expected_safepoint_kind_ = kind;
 
+      UseScratchRegisterScope temps(codegen_->masm_);
+      // Preserve the value of lr which must be saved on the stack (the call to
+      // the stub will clobber it).
+      Register to_be_pushed_lr =
+          temps.Acquire(StoreRegistersStateStub::to_be_pushed_lr());
+      codegen_->masm_->Mov(to_be_pushed_lr, lr);

[ulan, 2014/03/24 11:09:25]

to_be_pushed_lr is ip0, how do we guarantee that this doesn't get clobbered from
this point until the StoreRegistersStateStub gets control?

[vincent.belliard, 2014/03/24 11:16:59]

This register is reserved by the UseScratchRegisterScope so it cannot be used by
the call (which will use the next register: ip1).

After the call, we jump directly to the stub code (which has its own context)
which starts also by a UseScratchRegisterScope which also reserves
to_be_pushed_lr.

[ulan, 2014/03/24 11:31:26]

Right, and what if the ip0 is not available in the current scope because it was
already reserved before PushSafepointRegistersScope?

[vincent.belliard, 2014/03/24 11:43:28]

In debug, Acquire checks that the register is available. If each instruction
which use a PushSafepointRegistersScope is used by the at least one test (I hope
all are used) and if the tests are run in debug, it will ensure that the
register will be available.

In release, the register could be unavailable and still acquired (no test is
done during acquire). If it's not available, we will clobber it. However, it
doesn't matter because as we enter PushSafepointRegistersScope, only the
safepoint registers must be saved and ip0, ip1 can be cloberred.

[ulan, 2014/03/24 12:23:51]

OK, thank you for explanation. I went through the call sites of
PushSafepointRegistersScope, and they seem safe to me. Since Acquire(reg) is
unsafe in general case, let's rename it to UnsafeAcquire and add a comment there
explaining when one can use it.

[vincent.belliard, 2014/03/24 16:03:52]

done

       switch (codegen_->expected_safepoint_kind_) {
-        case Safepoint::kWithRegisters:
-          codegen_->masm_->PushSafepointRegisters();
+        case Safepoint::kWithRegisters: {
+          StoreRegistersStateStub stub(kDontSaveFPRegs);
+          codegen_->masm_->CallStub(&stub);
           break;
-        case Safepoint::kWithRegistersAndDoubles:
-          codegen_->masm_->PushSafepointRegisters();
-          codegen_->masm_->PushSafepointFPRegisters();
+        }
+        case Safepoint::kWithRegistersAndDoubles: {
+          StoreRegistersStateStub stub(kSaveFPRegs);
+          codegen_->masm_->CallStub(&stub);
           break;
+        }
         default:
           UNREACHABLE();
       }
     }
 
     ~PushSafepointRegistersScope() {
       Safepoint::Kind kind = codegen_->expected_safepoint_kind_;
       ASSERT((kind & Safepoint::kWithRegisters) != 0);
       switch (kind) {
-        case Safepoint::kWithRegisters:
-          codegen_->masm_->PopSafepointRegisters();
+        case Safepoint::kWithRegisters: {
+          RestoreRegistersStateStub stub(kDontSaveFPRegs);
+          codegen_->masm_->CallStub(&stub);
           break;
-        case Safepoint::kWithRegistersAndDoubles:
-          codegen_->masm_->PopSafepointFPRegisters();
-          codegen_->masm_->PopSafepointRegisters();
+        }
+        case Safepoint::kWithRegistersAndDoubles: {
+          RestoreRegistersStateStub stub(kSaveFPRegs);
+          codegen_->masm_->CallStub(&stub);
           break;
+        }
         default:
           UNREACHABLE();
       }
       codegen_->expected_safepoint_kind_ = Safepoint::kSimple;
     }
 
    private:
     LCodeGen* codegen_;
   };
 
@@ skipping 53 matching lines @@
 
  protected:
   MacroAssembler* masm() const { return codegen_->masm(); }
 
   LCodeGen* codegen_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_LITHIUM_CODEGEN_ARM64_H_