/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "calling_convention_x86_64.h" #include "base/bit_utils.h" #include "base/logging.h" #include "handle_scope-inl.h" #include "utils/x86_64/managed_register_x86_64.h" namespace art { namespace x86_64 { // Calling convention ManagedRegister X86_64ManagedRuntimeCallingConvention::InterproceduralScratchRegister() { return X86_64ManagedRegister::FromCpuRegister(RAX); } ManagedRegister X86_64JniCallingConvention::InterproceduralScratchRegister() { return X86_64ManagedRegister::FromCpuRegister(RAX); } ManagedRegister X86_64JniCallingConvention::ReturnScratchRegister() const { return ManagedRegister::NoRegister(); // No free regs, so assembler uses push/pop } static ManagedRegister ReturnRegisterForShorty(const char* shorty, bool jni ATTRIBUTE_UNUSED) { if (shorty[0] == 'F' || shorty[0] == 'D') { return X86_64ManagedRegister::FromXmmRegister(XMM0); } else if (shorty[0] == 'J') { return X86_64ManagedRegister::FromCpuRegister(RAX); } else if (shorty[0] == 'V') { return ManagedRegister::NoRegister(); } else { return X86_64ManagedRegister::FromCpuRegister(RAX); } } ManagedRegister X86_64ManagedRuntimeCallingConvention::ReturnRegister() { return ReturnRegisterForShorty(GetShorty(), false); } ManagedRegister X86_64JniCallingConvention::ReturnRegister() { return ReturnRegisterForShorty(GetShorty(), true); } ManagedRegister X86_64JniCallingConvention::IntReturnRegister() { return X86_64ManagedRegister::FromCpuRegister(RAX); } // Managed runtime calling convention ManagedRegister X86_64ManagedRuntimeCallingConvention::MethodRegister() { return X86_64ManagedRegister::FromCpuRegister(RDI); } bool X86_64ManagedRuntimeCallingConvention::IsCurrentParamInRegister() { return !IsCurrentParamOnStack(); } bool X86_64ManagedRuntimeCallingConvention::IsCurrentParamOnStack() { // We assume all parameters are on stack, args coming via registers are spilled as entry_spills return true; } ManagedRegister X86_64ManagedRuntimeCallingConvention::CurrentParamRegister() { ManagedRegister res = ManagedRegister::NoRegister(); if (!IsCurrentParamAFloatOrDouble()) { switch (itr_args_ - itr_float_and_doubles_) { case 0: res = X86_64ManagedRegister::FromCpuRegister(RSI); break; case 1: res = X86_64ManagedRegister::FromCpuRegister(RDX); break; case 2: res = X86_64ManagedRegister::FromCpuRegister(RCX); break; case 3: res = X86_64ManagedRegister::FromCpuRegister(R8); break; case 4: res = X86_64ManagedRegister::FromCpuRegister(R9); break; } } else if (itr_float_and_doubles_ < 8) { // First eight float parameters are passed via XMM0..XMM7 res = X86_64ManagedRegister::FromXmmRegister( static_cast<FloatRegister>(XMM0 + itr_float_and_doubles_)); } return res; } FrameOffset X86_64ManagedRuntimeCallingConvention::CurrentParamStackOffset() { return FrameOffset(displacement_.Int32Value() + // displacement kX86_64PointerSize + // Method ref itr_slots_ * sizeof(uint32_t)); // offset into in args } const ManagedRegisterEntrySpills& X86_64ManagedRuntimeCallingConvention::EntrySpills() { // We spill the argument registers on X86 to free them up for scratch use, we then assume // all arguments are on the stack. if (entry_spills_.size() == 0) { ResetIterator(FrameOffset(0)); while (HasNext()) { ManagedRegister in_reg = CurrentParamRegister(); if (!in_reg.IsNoRegister()) { int32_t size = IsParamALongOrDouble(itr_args_)? 8 : 4; int32_t spill_offset = CurrentParamStackOffset().Uint32Value(); ManagedRegisterSpill spill(in_reg, size, spill_offset); entry_spills_.push_back(spill); } Next(); } } return entry_spills_; } // JNI calling convention X86_64JniCallingConvention::X86_64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty) : JniCallingConvention(is_static, is_synchronized, shorty, kFramePointerSize) { callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(RBX)); callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(RBP)); callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R12)); callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R13)); callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R14)); callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R15)); callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM12)); callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM13)); callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM14)); callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM15)); } uint32_t X86_64JniCallingConvention::CoreSpillMask() const { return 1 << RBX | 1 << RBP | 1 << R12 | 1 << R13 | 1 << R14 | 1 << R15 | 1 << kNumberOfCpuRegisters; } uint32_t X86_64JniCallingConvention::FpSpillMask() const { return 1 << XMM12 | 1 << XMM13 | 1 << XMM14 | 1 << XMM15; } size_t X86_64JniCallingConvention::FrameSize() { // Method*, return address and callee save area size, local reference segment state size_t frame_data_size = kX86_64PointerSize + (2 + CalleeSaveRegisters().size()) * kFramePointerSize; // References plus link_ (pointer) and number_of_references_ (uint32_t) for HandleScope header size_t handle_scope_size = HandleScope::SizeOf(kFramePointerSize, ReferenceCount()); // Plus return value spill area size return RoundUp(frame_data_size + handle_scope_size + SizeOfReturnValue(), kStackAlignment); } size_t X86_64JniCallingConvention::OutArgSize() { return RoundUp(NumberOfOutgoingStackArgs() * kFramePointerSize, kStackAlignment); } bool X86_64JniCallingConvention::IsCurrentParamInRegister() { return !IsCurrentParamOnStack(); } bool X86_64JniCallingConvention::IsCurrentParamOnStack() { return CurrentParamRegister().IsNoRegister(); } ManagedRegister X86_64JniCallingConvention::CurrentParamRegister() { ManagedRegister res = ManagedRegister::NoRegister(); if (!IsCurrentParamAFloatOrDouble()) { switch (itr_args_ - itr_float_and_doubles_) { case 0: res = X86_64ManagedRegister::FromCpuRegister(RDI); break; case 1: res = X86_64ManagedRegister::FromCpuRegister(RSI); break; case 2: res = X86_64ManagedRegister::FromCpuRegister(RDX); break; case 3: res = X86_64ManagedRegister::FromCpuRegister(RCX); break; case 4: res = X86_64ManagedRegister::FromCpuRegister(R8); break; case 5: res = X86_64ManagedRegister::FromCpuRegister(R9); break; } } else if (itr_float_and_doubles_ < 8) { // First eight float parameters are passed via XMM0..XMM7 res = X86_64ManagedRegister::FromXmmRegister( static_cast<FloatRegister>(XMM0 + itr_float_and_doubles_)); } return res; } FrameOffset X86_64JniCallingConvention::CurrentParamStackOffset() { size_t offset = itr_args_ - std::min(8U, itr_float_and_doubles_) // Float arguments passed through Xmm0..Xmm7 - std::min(6U, itr_args_ - itr_float_and_doubles_); // Integer arguments passed through GPR return FrameOffset(displacement_.Int32Value() - OutArgSize() + (offset * kFramePointerSize)); } size_t X86_64JniCallingConvention::NumberOfOutgoingStackArgs() { size_t static_args = IsStatic() ? 1 : 0; // count jclass // regular argument parameters and this size_t param_args = NumArgs() + NumLongOrDoubleArgs(); // count JNIEnv* and return pc (pushed after Method*) size_t total_args = static_args + param_args + 2; // Float arguments passed through Xmm0..Xmm7 // Other (integer) arguments passed through GPR (RDI, RSI, RDX, RCX, R8, R9) size_t total_stack_args = total_args - std::min(8U, static_cast<unsigned int>(NumFloatOrDoubleArgs())) - std::min(6U, static_cast<unsigned int>(NumArgs() - NumFloatOrDoubleArgs())); return total_stack_args; } } // namespace x86_64 } // namespace art