Home | History | Annotate | Download | only in dex 
      1 /*
      2  * Copyright (C) 2014 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 #ifndef ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_
     18 #define ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_
     19 
     20 #include "base/macros.h"
     21 #include "base/mutex.h"
     22 #include "dex/dex_file.h"
     23 #include "dex/dex_instruction.h"
     24 #include "dex/method_reference.h"
     25 
     26 /*
     27  * NOTE: This code is part of the quick compiler. It lives in the runtime
     28  * only to allow the debugger to check whether a method has been inlined.
     29  */
     30 
     31 namespace art {
     32 
     33 class CodeItemDataAccessor;
     34 
     35 namespace verifier {
     36 class MethodVerifier;
     37 }  // namespace verifier
     38 class ArtMethod;
     39 
     40 enum InlineMethodOpcode : uint16_t {
     41   kInlineOpNop,
     42   kInlineOpReturnArg,
     43   kInlineOpNonWideConst,
     44   kInlineOpIGet,
     45   kInlineOpIPut,
     46   kInlineOpConstructor,
     47 };
     48 
     49 struct InlineIGetIPutData {
     50   // The op_variant below is DexMemAccessType but the runtime doesn't know that enumeration.
     51   uint16_t op_variant : 3;
     52   uint16_t method_is_static : 1;
     53   uint16_t object_arg : 4;
     54   uint16_t src_arg : 4;  // iput only
     55   uint16_t return_arg_plus1 : 4;  // iput only, method argument to return + 1, 0 = return void.
     56   uint16_t field_idx;
     57   uint32_t is_volatile : 1;
     58   uint32_t field_offset : 31;
     59 };
     60 static_assert(sizeof(InlineIGetIPutData) == sizeof(uint64_t), "Invalid size of InlineIGetIPutData");
     61 
     62 struct InlineReturnArgData {
     63   uint16_t arg;
     64   uint16_t is_wide : 1;
     65   uint16_t is_object : 1;
     66   uint16_t reserved : 14;
     67   uint32_t reserved2;
     68 };
     69 static_assert(sizeof(InlineReturnArgData) == sizeof(uint64_t),
     70               "Invalid size of InlineReturnArgData");
     71 
     72 struct InlineConstructorData {
     73   // There can be up to 3 IPUTs, unused fields are marked with kNoDexIndex16.
     74   uint16_t iput0_field_index;
     75   uint16_t iput1_field_index;
     76   uint16_t iput2_field_index;
     77   uint16_t iput0_arg : 4;
     78   uint16_t iput1_arg : 4;
     79   uint16_t iput2_arg : 4;
     80   uint16_t reserved : 4;
     81 };
     82 static_assert(sizeof(InlineConstructorData) == sizeof(uint64_t),
     83               "Invalid size of InlineConstructorData");
     84 
     85 struct InlineMethod {
     86   InlineMethodOpcode opcode;
     87   union {
     88     uint64_t data;
     89     InlineIGetIPutData ifield_data;
     90     InlineReturnArgData return_data;
     91     InlineConstructorData constructor_data;
     92   } d;
     93 };
     94 
     95 class InlineMethodAnalyser {
     96  public:
     97   /**
     98    * Analyse method code to determine if the method is a candidate for inlining.
     99    * If it is, record the inlining data.
    100    *
    101    * @return true if the method is a candidate for inlining, false otherwise.
    102    */
    103   static bool AnalyseMethodCode(ArtMethod* method, InlineMethod* result)
    104       REQUIRES_SHARED(Locks::mutator_lock_);
    105 
    106   static constexpr bool IsInstructionIGet(Instruction::Code opcode) {
    107     return Instruction::IGET <= opcode && opcode <= Instruction::IGET_SHORT;
    108   }
    109 
    110   static constexpr bool IsInstructionIPut(Instruction::Code opcode) {
    111     return Instruction::IPUT <= opcode && opcode <= Instruction::IPUT_SHORT;
    112   }
    113 
    114   static constexpr uint16_t IGetVariant(Instruction::Code opcode) {
    115     return opcode - Instruction::IGET;
    116   }
    117 
    118   static constexpr uint16_t IPutVariant(Instruction::Code opcode) {
    119     return opcode - Instruction::IPUT;
    120   }
    121 
    122   // Determines whether the method is a synthetic accessor (method name starts with "access$").
    123   static bool IsSyntheticAccessor(MethodReference ref);
    124 
    125  private:
    126   static bool AnalyseMethodCode(const CodeItemDataAccessor* code_item,
    127                                 const MethodReference& method_ref,
    128                                 bool is_static,
    129                                 ArtMethod* method,
    130                                 InlineMethod* result)
    131       REQUIRES_SHARED(Locks::mutator_lock_);
    132   static bool AnalyseReturnMethod(const CodeItemDataAccessor* code_item, InlineMethod* result);
    133   static bool AnalyseConstMethod(const CodeItemDataAccessor* code_item, InlineMethod* result);
    134   static bool AnalyseIGetMethod(const CodeItemDataAccessor* code_item,
    135                                 const MethodReference& method_ref,
    136                                 bool is_static,
    137                                 ArtMethod* method,
    138                                 InlineMethod* result)
    139       REQUIRES_SHARED(Locks::mutator_lock_);
    140   static bool AnalyseIPutMethod(const CodeItemDataAccessor* code_item,
    141                                 const MethodReference& method_ref,
    142                                 bool is_static,
    143                                 ArtMethod* method,
    144                                 InlineMethod* result)
    145       REQUIRES_SHARED(Locks::mutator_lock_);
    146 
    147   // Can we fast path instance field access in a verified accessor?
    148   // If yes, computes field's offset and volatility and whether the method is static or not.
    149   static bool ComputeSpecialAccessorInfo(ArtMethod* method,
    150                                          uint32_t field_idx,
    151                                          bool is_put,
    152                                          InlineIGetIPutData* result)
    153       REQUIRES_SHARED(Locks::mutator_lock_);
    154 };
    155 
    156 }  // namespace art
    157 
    158 #endif  // ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_
    159