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