Home | History | Annotate | Download | only in arm
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "base/logging.h"
     18 #include "calling_convention_arm.h"
     19 #include "utils/arm/managed_register_arm.h"
     20 
     21 namespace art {
     22 namespace arm {
     23 
     24 // Calling convention
     25 
     26 ManagedRegister ArmManagedRuntimeCallingConvention::InterproceduralScratchRegister() {
     27   return ArmManagedRegister::FromCoreRegister(IP);  // R12
     28 }
     29 
     30 ManagedRegister ArmJniCallingConvention::InterproceduralScratchRegister() {
     31   return ArmManagedRegister::FromCoreRegister(IP);  // R12
     32 }
     33 
     34 static ManagedRegister ReturnRegisterForShorty(const char* shorty) {
     35   if (shorty[0] == 'F') {
     36     return ArmManagedRegister::FromCoreRegister(R0);
     37   } else if (shorty[0] == 'D') {
     38     return ArmManagedRegister::FromRegisterPair(R0_R1);
     39   } else if (shorty[0] == 'J') {
     40     return ArmManagedRegister::FromRegisterPair(R0_R1);
     41   } else if (shorty[0] == 'V') {
     42     return ArmManagedRegister::NoRegister();
     43   } else {
     44     return ArmManagedRegister::FromCoreRegister(R0);
     45   }
     46 }
     47 
     48 ManagedRegister ArmManagedRuntimeCallingConvention::ReturnRegister() {
     49   return ReturnRegisterForShorty(GetShorty());
     50 }
     51 
     52 ManagedRegister ArmJniCallingConvention::ReturnRegister() {
     53   return ReturnRegisterForShorty(GetShorty());
     54 }
     55 
     56 ManagedRegister ArmJniCallingConvention::IntReturnRegister() {
     57   return ArmManagedRegister::FromCoreRegister(R0);
     58 }
     59 
     60 // Managed runtime calling convention
     61 
     62 ManagedRegister ArmManagedRuntimeCallingConvention::MethodRegister() {
     63   return ArmManagedRegister::FromCoreRegister(R0);
     64 }
     65 
     66 bool ArmManagedRuntimeCallingConvention::IsCurrentParamInRegister() {
     67   return false;  // Everything moved to stack on entry.
     68 }
     69 
     70 bool ArmManagedRuntimeCallingConvention::IsCurrentParamOnStack() {
     71   return true;
     72 }
     73 
     74 ManagedRegister ArmManagedRuntimeCallingConvention::CurrentParamRegister() {
     75   LOG(FATAL) << "Should not reach here";
     76   return ManagedRegister::NoRegister();
     77 }
     78 
     79 FrameOffset ArmManagedRuntimeCallingConvention::CurrentParamStackOffset() {
     80   CHECK(IsCurrentParamOnStack());
     81   FrameOffset result =
     82       FrameOffset(displacement_.Int32Value() +        // displacement
     83                   kFramePointerSize +                 // Method*
     84                   (itr_slots_ * kFramePointerSize));  // offset into in args
     85   return result;
     86 }
     87 
     88 const ManagedRegisterEntrySpills& ArmManagedRuntimeCallingConvention::EntrySpills() {
     89   // We spill the argument registers on ARM to free them up for scratch use, we then assume
     90   // all arguments are on the stack.
     91   if (entry_spills_.size() == 0) {
     92     size_t num_spills = NumArgs() + NumLongOrDoubleArgs();
     93     if (num_spills > 0) {
     94       entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R1));
     95       if (num_spills > 1) {
     96         entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R2));
     97         if (num_spills > 2) {
     98           entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R3));
     99         }
    100       }
    101     }
    102   }
    103   return entry_spills_;
    104 }
    105 // JNI calling convention
    106 
    107 ArmJniCallingConvention::ArmJniCallingConvention(bool is_static, bool is_synchronized,
    108                                                  const char* shorty)
    109     : JniCallingConvention(is_static, is_synchronized, shorty, kFramePointerSize) {
    110   // Compute padding to ensure longs and doubles are not split in AAPCS. Ignore the 'this' jobject
    111   // or jclass for static methods and the JNIEnv. We start at the aligned register r2.
    112   size_t padding = 0;
    113   for (size_t cur_arg = IsStatic() ? 0 : 1, cur_reg = 2; cur_arg < NumArgs(); cur_arg++) {
    114     if (IsParamALongOrDouble(cur_arg)) {
    115       if ((cur_reg & 1) != 0) {
    116         padding += 4;
    117         cur_reg++;  // additional bump to ensure alignment
    118       }
    119       cur_reg++;  // additional bump to skip extra long word
    120     }
    121     cur_reg++;  // bump the iterator for every argument
    122   }
    123   padding_ = padding;
    124 
    125   callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R5));
    126   callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R6));
    127   callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R7));
    128   callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R8));
    129   callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R10));
    130   callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R11));
    131 }
    132 
    133 uint32_t ArmJniCallingConvention::CoreSpillMask() const {
    134   // Compute spill mask to agree with callee saves initialized in the constructor
    135   uint32_t result = 0;
    136   result = 1 << R5 | 1 << R6 | 1 << R7 | 1 << R8 | 1 << R10 | 1 << R11 | 1 << LR;
    137   return result;
    138 }
    139 
    140 ManagedRegister ArmJniCallingConvention::ReturnScratchRegister() const {
    141   return ArmManagedRegister::FromCoreRegister(R2);
    142 }
    143 
    144 size_t ArmJniCallingConvention::FrameSize() {
    145   // Method*, LR and callee save area size, local reference segment state
    146   size_t frame_data_size = sizeof(StackReference<mirror::ArtMethod>) +
    147       (2 + CalleeSaveRegisters().size()) * kFramePointerSize;
    148   // References plus 2 words for HandleScope header
    149   size_t handle_scope_size = HandleScope::SizeOf(kFramePointerSize, ReferenceCount());
    150   // Plus return value spill area size
    151   return RoundUp(frame_data_size + handle_scope_size + SizeOfReturnValue(), kStackAlignment);
    152 }
    153 
    154 size_t ArmJniCallingConvention::OutArgSize() {
    155   return RoundUp(NumberOfOutgoingStackArgs() * kFramePointerSize + padding_,
    156                  kStackAlignment);
    157 }
    158 
    159 // JniCallingConvention ABI follows AAPCS where longs and doubles must occur
    160 // in even register numbers and stack slots
    161 void ArmJniCallingConvention::Next() {
    162   JniCallingConvention::Next();
    163   size_t arg_pos = itr_args_ - NumberOfExtraArgumentsForJni();
    164   if ((itr_args_ >= 2) &&
    165       (arg_pos < NumArgs()) &&
    166       IsParamALongOrDouble(arg_pos)) {
    167     // itr_slots_ needs to be an even number, according to AAPCS.
    168     if ((itr_slots_ & 0x1u) != 0) {
    169       itr_slots_++;
    170     }
    171   }
    172 }
    173 
    174 bool ArmJniCallingConvention::IsCurrentParamInRegister() {
    175   return itr_slots_ < 4;
    176 }
    177 
    178 bool ArmJniCallingConvention::IsCurrentParamOnStack() {
    179   return !IsCurrentParamInRegister();
    180 }
    181 
    182 static const Register kJniArgumentRegisters[] = {
    183   R0, R1, R2, R3
    184 };
    185 ManagedRegister ArmJniCallingConvention::CurrentParamRegister() {
    186   CHECK_LT(itr_slots_, 4u);
    187   int arg_pos = itr_args_ - NumberOfExtraArgumentsForJni();
    188   if ((itr_args_ >= 2) && IsParamALongOrDouble(arg_pos)) {
    189     CHECK_EQ(itr_slots_, 2u);
    190     return ArmManagedRegister::FromRegisterPair(R2_R3);
    191   } else {
    192     return
    193       ArmManagedRegister::FromCoreRegister(kJniArgumentRegisters[itr_slots_]);
    194   }
    195 }
    196 
    197 FrameOffset ArmJniCallingConvention::CurrentParamStackOffset() {
    198   CHECK_GE(itr_slots_, 4u);
    199   size_t offset = displacement_.Int32Value() - OutArgSize() + ((itr_slots_ - 4) * kFramePointerSize);
    200   CHECK_LT(offset, OutArgSize());
    201   return FrameOffset(offset);
    202 }
    203 
    204 size_t ArmJniCallingConvention::NumberOfOutgoingStackArgs() {
    205   size_t static_args = IsStatic() ? 1 : 0;  // count jclass
    206   // regular argument parameters and this
    207   size_t param_args = NumArgs() + NumLongOrDoubleArgs();
    208   // count JNIEnv* less arguments in registers
    209   return static_args + param_args + 1 - 4;
    210 }
    211 
    212 }  // namespace arm
    213 }  // namespace art
    214