Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 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 | */ |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 16 | |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 17 | #include "mir_to_lir-inl.h" |
| 18 | |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 19 | #include <functional> |
| 20 | |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 21 | #include "arch/arm/instruction_set_features_arm.h" |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 22 | #include "base/macros.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 23 | #include "dex/compiler_ir.h" |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 24 | #include "dex/mir_graph.h" |
Brian Carlstrom | 60d7a65 | 2014-03-13 18:10:08 -0700 | [diff] [blame] | 25 | #include "dex/quick/arm/arm_lir.h" |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 26 | #include "driver/compiler_driver.h" |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 27 | #include "driver/compiler_options.h" |
Ian Rogers | 166db04 | 2013-07-26 12:05:57 -0700 | [diff] [blame] | 28 | #include "entrypoints/quick/quick_entrypoints.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 29 | #include "mirror/array.h" |
Andreas Gampe | 9c3b089 | 2014-04-24 17:33:34 +0000 | [diff] [blame] | 30 | #include "mirror/object_array-inl.h" |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 31 | #include "mirror/object-inl.h" |
Andreas Gampe | aa910d5 | 2014-07-30 18:59:05 -0700 | [diff] [blame] | 32 | #include "mirror/object_reference.h" |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 33 | #include "utils.h" |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 34 | #include "utils/dex_cache_arrays_layout-inl.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 35 | #include "verifier/method_verifier.h" |
| 36 | |
| 37 | namespace art { |
| 38 | |
Andreas Gampe | 9c3b089 | 2014-04-24 17:33:34 +0000 | [diff] [blame] | 39 | // Shortcuts to repeatedly used long types. |
| 40 | typedef mirror::ObjectArray<mirror::Object> ObjArray; |
| 41 | typedef mirror::ObjectArray<mirror::Class> ClassArray; |
| 42 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 43 | /* |
| 44 | * This source files contains "gen" codegen routines that should |
| 45 | * be applicable to most targets. Only mid-level support utilities |
| 46 | * and "op" calls may be used here. |
| 47 | */ |
| 48 | |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 49 | ALWAYS_INLINE static inline bool ForceSlowFieldPath(CompilationUnit* cu) { |
| 50 | return (cu->enable_debug & (1 << kDebugSlowFieldPath)) != 0; |
| 51 | } |
| 52 | |
| 53 | ALWAYS_INLINE static inline bool ForceSlowStringPath(CompilationUnit* cu) { |
| 54 | return (cu->enable_debug & (1 << kDebugSlowStringPath)) != 0; |
| 55 | } |
| 56 | |
| 57 | ALWAYS_INLINE static inline bool ForceSlowTypePath(CompilationUnit* cu) { |
| 58 | return (cu->enable_debug & (1 << kDebugSlowTypePath)) != 0; |
| 59 | } |
| 60 | |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 61 | void Mir2Lir::GenIfNullUseHelperImmMethod( |
| 62 | RegStorage r_result, QuickEntrypointEnum trampoline, int imm, RegStorage r_method) { |
| 63 | class CallHelperImmMethodSlowPath : public LIRSlowPath { |
| 64 | public: |
| 65 | CallHelperImmMethodSlowPath(Mir2Lir* m2l, LIR* fromfast, LIR* cont, |
| 66 | QuickEntrypointEnum trampoline_in, int imm_in, |
| 67 | RegStorage r_method_in, RegStorage r_result_in) |
| 68 | : LIRSlowPath(m2l, fromfast, cont), trampoline_(trampoline_in), |
| 69 | imm_(imm_in), r_method_(r_method_in), r_result_(r_result_in) { |
| 70 | } |
| 71 | |
| 72 | void Compile() { |
| 73 | GenerateTargetLabel(); |
| 74 | if (r_method_.Valid()) { |
| 75 | m2l_->CallRuntimeHelperImmReg(trampoline_, imm_, r_method_, true); |
| 76 | } else { |
| 77 | m2l_->CallRuntimeHelperImmMethod(trampoline_, imm_, true); |
| 78 | } |
| 79 | m2l_->OpRegCopy(r_result_, m2l_->TargetReg(kRet0, kRef)); |
| 80 | m2l_->OpUnconditionalBranch(cont_); |
| 81 | } |
| 82 | |
| 83 | private: |
| 84 | QuickEntrypointEnum trampoline_; |
| 85 | const int imm_; |
| 86 | const RegStorage r_method_; |
| 87 | const RegStorage r_result_; |
| 88 | }; |
| 89 | |
| 90 | LIR* branch = OpCmpImmBranch(kCondEq, r_result, 0, NULL); |
| 91 | LIR* cont = NewLIR0(kPseudoTargetLabel); |
| 92 | |
| 93 | AddSlowPath(new (arena_) CallHelperImmMethodSlowPath(this, branch, cont, trampoline, imm, |
| 94 | r_method, r_result)); |
| 95 | } |
| 96 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 97 | /* |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 98 | * Generate a kPseudoBarrier marker to indicate the boundary of special |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 99 | * blocks. |
| 100 | */ |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 101 | void Mir2Lir::GenBarrier() { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 102 | LIR* barrier = NewLIR0(kPseudoBarrier); |
| 103 | /* Mark all resources as being clobbered */ |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 104 | DCHECK(!barrier->flags.use_def_invalid); |
Vladimir Marko | 8dea81c | 2014-06-06 14:50:36 +0100 | [diff] [blame] | 105 | barrier->u.m.def_mask = &kEncodeAll; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 106 | } |
| 107 | |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 108 | void Mir2Lir::GenDivZeroException() { |
| 109 | LIR* branch = OpUnconditionalBranch(nullptr); |
| 110 | AddDivZeroCheckSlowPath(branch); |
| 111 | } |
| 112 | |
| 113 | void Mir2Lir::GenDivZeroCheck(ConditionCode c_code) { |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 114 | LIR* branch = OpCondBranch(c_code, nullptr); |
| 115 | AddDivZeroCheckSlowPath(branch); |
| 116 | } |
| 117 | |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 118 | void Mir2Lir::GenDivZeroCheck(RegStorage reg) { |
| 119 | LIR* branch = OpCmpImmBranch(kCondEq, reg, 0, nullptr); |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 120 | AddDivZeroCheckSlowPath(branch); |
| 121 | } |
| 122 | |
| 123 | void Mir2Lir::AddDivZeroCheckSlowPath(LIR* branch) { |
| 124 | class DivZeroCheckSlowPath : public Mir2Lir::LIRSlowPath { |
| 125 | public: |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 126 | DivZeroCheckSlowPath(Mir2Lir* m2l, LIR* branch_in) |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 127 | : LIRSlowPath(m2l, branch_in) { |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 128 | } |
| 129 | |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 130 | void Compile() OVERRIDE { |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 131 | m2l_->ResetRegPool(); |
| 132 | m2l_->ResetDefTracking(); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 133 | GenerateTargetLabel(kPseudoThrowTarget); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 134 | m2l_->CallRuntimeHelper(kQuickThrowDivZero, true); |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 135 | } |
| 136 | }; |
| 137 | |
| 138 | AddSlowPath(new (arena_) DivZeroCheckSlowPath(this, branch)); |
| 139 | } |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 140 | |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 141 | void Mir2Lir::GenArrayBoundsCheck(RegStorage index, RegStorage length) { |
| 142 | class ArrayBoundsCheckSlowPath : public Mir2Lir::LIRSlowPath { |
| 143 | public: |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 144 | ArrayBoundsCheckSlowPath(Mir2Lir* m2l, LIR* branch_in, RegStorage index_in, |
| 145 | RegStorage length_in) |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 146 | : LIRSlowPath(m2l, branch_in), |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 147 | index_(index_in), length_(length_in) { |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | void Compile() OVERRIDE { |
| 151 | m2l_->ResetRegPool(); |
| 152 | m2l_->ResetDefTracking(); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 153 | GenerateTargetLabel(kPseudoThrowTarget); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 154 | m2l_->CallRuntimeHelperRegReg(kQuickThrowArrayBounds, index_, length_, true); |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | private: |
| 158 | const RegStorage index_; |
| 159 | const RegStorage length_; |
| 160 | }; |
| 161 | |
| 162 | LIR* branch = OpCmpBranch(kCondUge, index, length, nullptr); |
| 163 | AddSlowPath(new (arena_) ArrayBoundsCheckSlowPath(this, branch, index, length)); |
| 164 | } |
| 165 | |
| 166 | void Mir2Lir::GenArrayBoundsCheck(int index, RegStorage length) { |
| 167 | class ArrayBoundsCheckSlowPath : public Mir2Lir::LIRSlowPath { |
| 168 | public: |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 169 | ArrayBoundsCheckSlowPath(Mir2Lir* m2l, LIR* branch_in, int index_in, RegStorage length_in) |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 170 | : LIRSlowPath(m2l, branch_in), |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 171 | index_(index_in), length_(length_in) { |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | void Compile() OVERRIDE { |
| 175 | m2l_->ResetRegPool(); |
| 176 | m2l_->ResetDefTracking(); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 177 | GenerateTargetLabel(kPseudoThrowTarget); |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 178 | |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 179 | RegStorage arg1_32 = m2l_->TargetReg(kArg1, kNotWide); |
| 180 | RegStorage arg0_32 = m2l_->TargetReg(kArg0, kNotWide); |
Andreas Gampe | 4b537a8 | 2014-06-30 22:24:53 -0700 | [diff] [blame] | 181 | |
| 182 | m2l_->OpRegCopy(arg1_32, length_); |
| 183 | m2l_->LoadConstant(arg0_32, index_); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 184 | m2l_->CallRuntimeHelperRegReg(kQuickThrowArrayBounds, arg0_32, arg1_32, true); |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | private: |
| 188 | const int32_t index_; |
| 189 | const RegStorage length_; |
| 190 | }; |
| 191 | |
| 192 | LIR* branch = OpCmpImmBranch(kCondLs, length, index, nullptr); |
| 193 | AddSlowPath(new (arena_) ArrayBoundsCheckSlowPath(this, branch, index, length)); |
| 194 | } |
| 195 | |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 196 | LIR* Mir2Lir::GenNullCheck(RegStorage reg) { |
| 197 | class NullCheckSlowPath : public Mir2Lir::LIRSlowPath { |
| 198 | public: |
| 199 | NullCheckSlowPath(Mir2Lir* m2l, LIR* branch) |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 200 | : LIRSlowPath(m2l, branch) { |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | void Compile() OVERRIDE { |
| 204 | m2l_->ResetRegPool(); |
| 205 | m2l_->ResetDefTracking(); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 206 | GenerateTargetLabel(kPseudoThrowTarget); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 207 | m2l_->CallRuntimeHelper(kQuickThrowNullPointer, true); |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 208 | } |
| 209 | }; |
| 210 | |
| 211 | LIR* branch = OpCmpImmBranch(kCondEq, reg, 0, nullptr); |
| 212 | AddSlowPath(new (arena_) NullCheckSlowPath(this, branch)); |
| 213 | return branch; |
| 214 | } |
| 215 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 216 | /* Perform null-check on a register. */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 217 | LIR* Mir2Lir::GenNullCheck(RegStorage m_reg, int opt_flags) { |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 218 | if (!cu_->compiler_driver->GetCompilerOptions().GetImplicitNullChecks()) { |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 219 | return GenExplicitNullCheck(m_reg, opt_flags); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 220 | } |
Pavel Vyssotski | 9c3617a | 2014-11-13 18:25:23 +0600 | [diff] [blame] | 221 | // If null check has not been eliminated, reset redundant store tracking. |
| 222 | if ((opt_flags & MIR_IGNORE_NULL_CHECK) == 0) { |
| 223 | ResetDefTracking(); |
| 224 | } |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 225 | return nullptr; |
| 226 | } |
| 227 | |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 228 | /* Perform an explicit null-check on a register. */ |
| 229 | LIR* Mir2Lir::GenExplicitNullCheck(RegStorage m_reg, int opt_flags) { |
| 230 | if (!(cu_->disable_opt & (1 << kNullCheckElimination)) && (opt_flags & MIR_IGNORE_NULL_CHECK)) { |
| 231 | return NULL; |
| 232 | } |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 233 | return GenNullCheck(m_reg); |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 234 | } |
| 235 | |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 236 | void Mir2Lir::MarkPossibleNullPointerException(int opt_flags) { |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 237 | if (cu_->compiler_driver->GetCompilerOptions().GetImplicitNullChecks()) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 238 | if (!(cu_->disable_opt & (1 << kNullCheckElimination)) && (opt_flags & MIR_IGNORE_NULL_CHECK)) { |
| 239 | return; |
| 240 | } |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 241 | // Insert after last instruction. |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 242 | MarkSafepointPC(last_lir_insn_); |
| 243 | } |
| 244 | } |
| 245 | |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 246 | void Mir2Lir::MarkPossibleNullPointerExceptionAfter(int opt_flags, LIR* after) { |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 247 | if (cu_->compiler_driver->GetCompilerOptions().GetImplicitNullChecks()) { |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 248 | if (!(cu_->disable_opt & (1 << kNullCheckElimination)) && (opt_flags & MIR_IGNORE_NULL_CHECK)) { |
| 249 | return; |
| 250 | } |
| 251 | MarkSafepointPCAfter(after); |
| 252 | } |
| 253 | } |
| 254 | |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 255 | void Mir2Lir::MarkPossibleStackOverflowException() { |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 256 | if (cu_->compiler_driver->GetCompilerOptions().GetImplicitStackOverflowChecks()) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 257 | MarkSafepointPC(last_lir_insn_); |
| 258 | } |
| 259 | } |
| 260 | |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 261 | void Mir2Lir::ForceImplicitNullCheck(RegStorage reg, int opt_flags) { |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 262 | if (cu_->compiler_driver->GetCompilerOptions().GetImplicitNullChecks()) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 263 | if (!(cu_->disable_opt & (1 << kNullCheckElimination)) && (opt_flags & MIR_IGNORE_NULL_CHECK)) { |
| 264 | return; |
| 265 | } |
| 266 | // Force an implicit null check by performing a memory operation (load) from the given |
| 267 | // register with offset 0. This will cause a signal if the register contains 0 (null). |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 268 | RegStorage tmp = AllocTemp(); |
| 269 | // TODO: for Mips, would be best to use rZERO as the bogus register target. |
buzbee | 695d13a | 2014-04-19 13:32:20 -0700 | [diff] [blame] | 270 | LIR* load = Load32Disp(reg, 0, tmp); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 271 | FreeTemp(tmp); |
| 272 | MarkSafepointPC(load); |
| 273 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 274 | } |
| 275 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 276 | void Mir2Lir::GenCompareAndBranch(Instruction::Code opcode, RegLocation rl_src1, |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 277 | RegLocation rl_src2, LIR* taken) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 278 | ConditionCode cond; |
buzbee | 7c02e91 | 2014-10-03 13:14:17 -0700 | [diff] [blame] | 279 | RegisterClass reg_class = (rl_src1.ref || rl_src2.ref) ? kRefReg : kCoreReg; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 280 | switch (opcode) { |
| 281 | case Instruction::IF_EQ: |
| 282 | cond = kCondEq; |
| 283 | break; |
| 284 | case Instruction::IF_NE: |
| 285 | cond = kCondNe; |
| 286 | break; |
| 287 | case Instruction::IF_LT: |
| 288 | cond = kCondLt; |
| 289 | break; |
| 290 | case Instruction::IF_GE: |
| 291 | cond = kCondGe; |
| 292 | break; |
| 293 | case Instruction::IF_GT: |
| 294 | cond = kCondGt; |
| 295 | break; |
| 296 | case Instruction::IF_LE: |
| 297 | cond = kCondLe; |
| 298 | break; |
| 299 | default: |
| 300 | cond = static_cast<ConditionCode>(0); |
| 301 | LOG(FATAL) << "Unexpected opcode " << opcode; |
| 302 | } |
| 303 | |
| 304 | // Normalize such that if either operand is constant, src2 will be constant |
| 305 | if (rl_src1.is_const) { |
| 306 | RegLocation rl_temp = rl_src1; |
| 307 | rl_src1 = rl_src2; |
| 308 | rl_src2 = rl_temp; |
| 309 | cond = FlipComparisonOrder(cond); |
| 310 | } |
| 311 | |
buzbee | 7c02e91 | 2014-10-03 13:14:17 -0700 | [diff] [blame] | 312 | rl_src1 = LoadValue(rl_src1, reg_class); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 313 | // Is this really an immediate comparison? |
| 314 | if (rl_src2.is_const) { |
| 315 | // If it's already live in a register or not easily materialized, just keep going |
| 316 | RegLocation rl_temp = UpdateLoc(rl_src2); |
Andreas Gampe | b07c1f9 | 2014-07-26 01:40:39 -0700 | [diff] [blame] | 317 | int32_t constant_value = mir_graph_->ConstantValue(rl_src2); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 318 | if ((rl_temp.location == kLocDalvikFrame) && |
Matteo Franchin | c763e35 | 2014-07-04 12:53:27 +0100 | [diff] [blame] | 319 | InexpensiveConstantInt(constant_value, opcode)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 320 | // OK - convert this to a compare immediate and branch |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 321 | OpCmpImmBranch(cond, rl_src1.reg, mir_graph_->ConstantValue(rl_src2), taken); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 322 | return; |
| 323 | } |
Andreas Gampe | b07c1f9 | 2014-07-26 01:40:39 -0700 | [diff] [blame] | 324 | |
| 325 | // It's also commonly more efficient to have a test against zero with Eq/Ne. This is not worse |
| 326 | // for x86, and allows a cbz/cbnz for Arm and Mips. At the same time, it works around a register |
| 327 | // mismatch for 64b systems, where a reference is compared against null, as dex bytecode uses |
| 328 | // the 32b literal 0 for null. |
| 329 | if (constant_value == 0 && (cond == kCondEq || cond == kCondNe)) { |
| 330 | // Use the OpCmpImmBranch and ignore the value in the register. |
| 331 | OpCmpImmBranch(cond, rl_src1.reg, 0, taken); |
| 332 | return; |
| 333 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 334 | } |
Andreas Gampe | b07c1f9 | 2014-07-26 01:40:39 -0700 | [diff] [blame] | 335 | |
buzbee | 7c02e91 | 2014-10-03 13:14:17 -0700 | [diff] [blame] | 336 | rl_src2 = LoadValue(rl_src2, reg_class); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 337 | OpCmpBranch(cond, rl_src1.reg, rl_src2.reg, taken); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 338 | } |
| 339 | |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 340 | void Mir2Lir::GenCompareZeroAndBranch(Instruction::Code opcode, RegLocation rl_src, LIR* taken) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 341 | ConditionCode cond; |
buzbee | 7c02e91 | 2014-10-03 13:14:17 -0700 | [diff] [blame] | 342 | RegisterClass reg_class = rl_src.ref ? kRefReg : kCoreReg; |
| 343 | rl_src = LoadValue(rl_src, reg_class); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 344 | switch (opcode) { |
| 345 | case Instruction::IF_EQZ: |
| 346 | cond = kCondEq; |
| 347 | break; |
| 348 | case Instruction::IF_NEZ: |
| 349 | cond = kCondNe; |
| 350 | break; |
| 351 | case Instruction::IF_LTZ: |
| 352 | cond = kCondLt; |
| 353 | break; |
| 354 | case Instruction::IF_GEZ: |
| 355 | cond = kCondGe; |
| 356 | break; |
| 357 | case Instruction::IF_GTZ: |
| 358 | cond = kCondGt; |
| 359 | break; |
| 360 | case Instruction::IF_LEZ: |
| 361 | cond = kCondLe; |
| 362 | break; |
| 363 | default: |
| 364 | cond = static_cast<ConditionCode>(0); |
| 365 | LOG(FATAL) << "Unexpected opcode " << opcode; |
| 366 | } |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 367 | OpCmpImmBranch(cond, rl_src.reg, 0, taken); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 368 | } |
| 369 | |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 370 | void Mir2Lir::GenIntToLong(RegLocation rl_dest, RegLocation rl_src) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 371 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 372 | if (rl_src.location == kLocPhysReg) { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 373 | OpRegCopy(rl_result.reg, rl_src.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 374 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 375 | LoadValueDirect(rl_src, rl_result.reg.GetLow()); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 376 | } |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 377 | OpRegRegImm(kOpAsr, rl_result.reg.GetHigh(), rl_result.reg.GetLow(), 31); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 378 | StoreValueWide(rl_dest, rl_result); |
| 379 | } |
| 380 | |
Yevgeny Rouban | 6af8206 | 2014-11-26 18:11:54 +0600 | [diff] [blame] | 381 | void Mir2Lir::GenLongToInt(RegLocation rl_dest, RegLocation rl_src) { |
| 382 | rl_src = UpdateLocWide(rl_src); |
| 383 | rl_src = NarrowRegLoc(rl_src); |
| 384 | StoreValue(rl_dest, rl_src); |
| 385 | } |
| 386 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 387 | void Mir2Lir::GenIntNarrowing(Instruction::Code opcode, RegLocation rl_dest, |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 388 | RegLocation rl_src) { |
Brian Carlstrom | 6f485c6 | 2013-07-18 15:35:35 -0700 | [diff] [blame] | 389 | rl_src = LoadValue(rl_src, kCoreReg); |
| 390 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 391 | OpKind op = kOpInvalid; |
| 392 | switch (opcode) { |
| 393 | case Instruction::INT_TO_BYTE: |
| 394 | op = kOp2Byte; |
| 395 | break; |
| 396 | case Instruction::INT_TO_SHORT: |
| 397 | op = kOp2Short; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 398 | break; |
Brian Carlstrom | 6f485c6 | 2013-07-18 15:35:35 -0700 | [diff] [blame] | 399 | case Instruction::INT_TO_CHAR: |
| 400 | op = kOp2Char; |
| 401 | break; |
| 402 | default: |
| 403 | LOG(ERROR) << "Bad int conversion type"; |
| 404 | } |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 405 | OpRegReg(op, rl_result.reg, rl_src.reg); |
Brian Carlstrom | 6f485c6 | 2013-07-18 15:35:35 -0700 | [diff] [blame] | 406 | StoreValue(rl_dest, rl_result); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 407 | } |
| 408 | |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 409 | /* |
| 410 | * Let helper function take care of everything. Will call |
| 411 | * Array::AllocFromCode(type_idx, method, count); |
| 412 | * Note: AllocFromCode will handle checks for errNegativeArraySize. |
| 413 | */ |
| 414 | void Mir2Lir::GenNewArray(uint32_t type_idx, RegLocation rl_dest, |
| 415 | RegLocation rl_src) { |
| 416 | FlushAllRegs(); /* Everything to home location */ |
| 417 | const DexFile* dex_file = cu_->dex_file; |
| 418 | CompilerDriver* driver = cu_->compiler_driver; |
| 419 | if (cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, *dex_file, type_idx)) { |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 420 | bool is_type_initialized; // Ignored as an array does not have an initializer. |
| 421 | bool use_direct_type_ptr; |
| 422 | uintptr_t direct_type_ptr; |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 423 | bool is_finalizable; |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 424 | if (kEmbedClassInCode && |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 425 | driver->CanEmbedTypeInCode(*dex_file, type_idx, &is_type_initialized, &use_direct_type_ptr, |
| 426 | &direct_type_ptr, &is_finalizable)) { |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 427 | // The fast path. |
| 428 | if (!use_direct_type_ptr) { |
Fred Shih | e7f82e2 | 2014-08-06 10:46:37 -0700 | [diff] [blame] | 429 | LoadClassType(*dex_file, type_idx, kArg0); |
Andreas Gampe | 1cc7dba | 2014-12-17 18:43:01 -0800 | [diff] [blame] | 430 | CallRuntimeHelperRegRegLocationMethod(kQuickAllocArrayResolved, TargetReg(kArg0, kNotWide), |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 431 | rl_src, true); |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 432 | } else { |
| 433 | // Use the direct pointer. |
Andreas Gampe | 1cc7dba | 2014-12-17 18:43:01 -0800 | [diff] [blame] | 434 | CallRuntimeHelperImmRegLocationMethod(kQuickAllocArrayResolved, direct_type_ptr, rl_src, |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 435 | true); |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 436 | } |
| 437 | } else { |
| 438 | // The slow path. |
Andreas Gampe | 1cc7dba | 2014-12-17 18:43:01 -0800 | [diff] [blame] | 439 | CallRuntimeHelperImmRegLocationMethod(kQuickAllocArray, type_idx, rl_src, true); |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 440 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 441 | } else { |
Andreas Gampe | 1cc7dba | 2014-12-17 18:43:01 -0800 | [diff] [blame] | 442 | CallRuntimeHelperImmRegLocationMethod(kQuickAllocArrayWithAccessCheck, type_idx, rl_src, true); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 443 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 444 | StoreValue(rl_dest, GetReturn(kRefReg)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 445 | } |
| 446 | |
| 447 | /* |
| 448 | * Similar to GenNewArray, but with post-allocation initialization. |
| 449 | * Verifier guarantees we're dealing with an array class. Current |
| 450 | * code throws runtime exception "bad Filled array req" for 'D' and 'J'. |
| 451 | * Current code also throws internal unimp if not 'L', '[' or 'I'. |
| 452 | */ |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 453 | void Mir2Lir::GenFilledNewArray(CallInfo* info) { |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 454 | size_t elems = info->num_arg_words; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 455 | int type_idx = info->index; |
| 456 | FlushAllRegs(); /* Everything to home location */ |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 457 | QuickEntrypointEnum target; |
| 458 | if (cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, *cu_->dex_file, |
| 459 | type_idx)) { |
| 460 | target = kQuickCheckAndAllocArray; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 461 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 462 | target = kQuickCheckAndAllocArrayWithAccessCheck; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 463 | } |
Andreas Gampe | 1cc7dba | 2014-12-17 18:43:01 -0800 | [diff] [blame] | 464 | CallRuntimeHelperImmImmMethod(target, type_idx, elems, true); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 465 | FreeTemp(TargetReg(kArg2, kNotWide)); |
| 466 | FreeTemp(TargetReg(kArg1, kNotWide)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 467 | /* |
| 468 | * NOTE: the implicit target for Instruction::FILLED_NEW_ARRAY is the |
| 469 | * return region. Because AllocFromCode placed the new array |
| 470 | * in kRet0, we'll just lock it into place. When debugger support is |
| 471 | * added, it may be necessary to additionally copy all return |
| 472 | * values to a home location in thread-local storage |
| 473 | */ |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 474 | RegStorage ref_reg = TargetReg(kRet0, kRef); |
Chao-ying Fu | a77ee51 | 2014-07-01 17:43:41 -0700 | [diff] [blame] | 475 | LockTemp(ref_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 476 | |
| 477 | // TODO: use the correct component size, currently all supported types |
| 478 | // share array alignment with ints (see comment at head of function) |
| 479 | size_t component_size = sizeof(int32_t); |
| 480 | |
Vladimir Marko | bf535be | 2014-11-19 18:52:35 +0000 | [diff] [blame] | 481 | if (elems > 5) { |
| 482 | DCHECK(info->is_range); // Non-range insn can't encode more than 5 elems. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 483 | /* |
| 484 | * Bit of ugliness here. We're going generate a mem copy loop |
| 485 | * on the register range, but it is possible that some regs |
| 486 | * in the range have been promoted. This is unlikely, but |
| 487 | * before generating the copy, we'll just force a flush |
| 488 | * of any regs in the source range that have been promoted to |
| 489 | * home location. |
| 490 | */ |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 491 | for (size_t i = 0; i < elems; i++) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 492 | RegLocation loc = UpdateLoc(info->args[i]); |
| 493 | if (loc.location == kLocPhysReg) { |
Vladimir Marko | 8dea81c | 2014-06-06 14:50:36 +0100 | [diff] [blame] | 494 | ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); |
Serguei Katkov | 2750354 | 2014-11-06 14:45:44 +0600 | [diff] [blame] | 495 | if (loc.ref) { |
| 496 | StoreRefDisp(TargetPtrReg(kSp), SRegOffset(loc.s_reg_low), loc.reg, kNotVolatile); |
| 497 | } else { |
| 498 | Store32Disp(TargetPtrReg(kSp), SRegOffset(loc.s_reg_low), loc.reg); |
| 499 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 500 | } |
| 501 | } |
| 502 | /* |
| 503 | * TUNING note: generated code here could be much improved, but |
| 504 | * this is an uncommon operation and isn't especially performance |
| 505 | * critical. |
| 506 | */ |
Chao-ying Fu | 7e399fd | 2014-06-10 18:11:11 -0700 | [diff] [blame] | 507 | // This is addressing the stack, which may be out of the 4G area. |
buzbee | 33ae558 | 2014-06-12 14:56:32 -0700 | [diff] [blame] | 508 | RegStorage r_src = AllocTempRef(); |
| 509 | RegStorage r_dst = AllocTempRef(); |
| 510 | RegStorage r_idx = AllocTempRef(); // Not really a reference, but match src/dst. |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 511 | RegStorage r_val; |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 512 | switch (cu_->instruction_set) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 513 | case kThumb2: |
buzbee | 33ae558 | 2014-06-12 14:56:32 -0700 | [diff] [blame] | 514 | case kArm64: |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 515 | r_val = TargetReg(kLr, kNotWide); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 516 | break; |
| 517 | case kX86: |
Dmitry Petrochenko | 6a58cb1 | 2014-04-02 17:27:59 +0700 | [diff] [blame] | 518 | case kX86_64: |
Chao-ying Fu | a77ee51 | 2014-07-01 17:43:41 -0700 | [diff] [blame] | 519 | FreeTemp(ref_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 520 | r_val = AllocTemp(); |
| 521 | break; |
| 522 | case kMips: |
Maja Gagic | 6ea651f | 2015-02-24 16:55:04 +0100 | [diff] [blame] | 523 | case kMips64: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 524 | r_val = AllocTemp(); |
| 525 | break; |
| 526 | default: LOG(FATAL) << "Unexpected instruction set: " << cu_->instruction_set; |
| 527 | } |
| 528 | // Set up source pointer |
| 529 | RegLocation rl_first = info->args[0]; |
Chao-ying Fu | a77ee51 | 2014-07-01 17:43:41 -0700 | [diff] [blame] | 530 | OpRegRegImm(kOpAdd, r_src, TargetPtrReg(kSp), SRegOffset(rl_first.s_reg_low)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 531 | // Set up the target pointer |
Chao-ying Fu | a77ee51 | 2014-07-01 17:43:41 -0700 | [diff] [blame] | 532 | OpRegRegImm(kOpAdd, r_dst, ref_reg, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 533 | mirror::Array::DataOffset(component_size).Int32Value()); |
| 534 | // Set up the loop counter (known to be > 0) |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 535 | LoadConstant(r_idx, static_cast<int>(elems - 1)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 536 | // Generate the copy loop. Going backwards for convenience |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 537 | LIR* loop_head_target = NewLIR0(kPseudoTargetLabel); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 538 | // Copy next element |
Vladimir Marko | 8dea81c | 2014-06-06 14:50:36 +0100 | [diff] [blame] | 539 | { |
| 540 | ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); |
| 541 | LoadBaseIndexed(r_src, r_idx, r_val, 2, k32); |
| 542 | // NOTE: No dalvik register annotation, local optimizations will be stopped |
| 543 | // by the loop boundaries. |
| 544 | } |
buzbee | 695d13a | 2014-04-19 13:32:20 -0700 | [diff] [blame] | 545 | StoreBaseIndexed(r_dst, r_idx, r_val, 2, k32); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 546 | FreeTemp(r_val); |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 547 | OpDecAndBranch(kCondGe, r_idx, loop_head_target); |
Dmitry Petrochenko | 6a58cb1 | 2014-04-02 17:27:59 +0700 | [diff] [blame] | 548 | if (cu_->instruction_set == kX86 || cu_->instruction_set == kX86_64) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 549 | // Restore the target pointer |
Chao-ying Fu | a77ee51 | 2014-07-01 17:43:41 -0700 | [diff] [blame] | 550 | OpRegRegImm(kOpAdd, ref_reg, r_dst, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 551 | -mirror::Array::DataOffset(component_size).Int32Value()); |
| 552 | } |
Vladimir Marko | bf535be | 2014-11-19 18:52:35 +0000 | [diff] [blame] | 553 | FreeTemp(r_idx); |
| 554 | FreeTemp(r_dst); |
| 555 | FreeTemp(r_src); |
| 556 | } else { |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 557 | DCHECK_LE(elems, 5u); // Usually but not necessarily non-range. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 558 | // TUNING: interleave |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 559 | for (size_t i = 0; i < elems; i++) { |
Serguei Katkov | 2750354 | 2014-11-06 14:45:44 +0600 | [diff] [blame] | 560 | RegLocation rl_arg; |
| 561 | if (info->args[i].ref) { |
| 562 | rl_arg = LoadValue(info->args[i], kRefReg); |
| 563 | StoreRefDisp(ref_reg, |
| 564 | mirror::Array::DataOffset(component_size).Int32Value() + i * 4, rl_arg.reg, |
| 565 | kNotVolatile); |
| 566 | } else { |
| 567 | rl_arg = LoadValue(info->args[i], kCoreReg); |
| 568 | Store32Disp(ref_reg, |
| 569 | mirror::Array::DataOffset(component_size).Int32Value() + i * 4, rl_arg.reg); |
| 570 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 571 | // If the LoadValue caused a temp to be allocated, free it |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 572 | if (IsTemp(rl_arg.reg)) { |
| 573 | FreeTemp(rl_arg.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 574 | } |
| 575 | } |
| 576 | } |
Vladimir Marko | bf535be | 2014-11-19 18:52:35 +0000 | [diff] [blame] | 577 | if (elems != 0 && info->args[0].ref) { |
| 578 | // If there is at least one potentially non-null value, unconditionally mark the GC card. |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 579 | for (size_t i = 0; i < elems; i++) { |
Vladimir Marko | bf535be | 2014-11-19 18:52:35 +0000 | [diff] [blame] | 580 | if (!mir_graph_->IsConstantNullRef(info->args[i])) { |
| 581 | UnconditionallyMarkGCCard(ref_reg); |
| 582 | break; |
| 583 | } |
| 584 | } |
| 585 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 586 | if (info->result.location != kLocInvalid) { |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 587 | StoreValue(info->result, GetReturn(kRefReg)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 588 | } |
| 589 | } |
| 590 | |
Ian Rogers | 832336b | 2014-10-08 15:35:22 -0700 | [diff] [blame] | 591 | /* |
| 592 | * Array data table format: |
| 593 | * ushort ident = 0x0300 magic value |
| 594 | * ushort width width of each element in the table |
| 595 | * uint size number of elements in the table |
| 596 | * ubyte data[size*width] table of data values (may contain a single-byte |
| 597 | * padding at the end) |
| 598 | * |
| 599 | * Total size is 4+(width * size + 1)/2 16-bit code units. |
| 600 | */ |
| 601 | void Mir2Lir::GenFillArrayData(MIR* mir, DexOffset table_offset, RegLocation rl_src) { |
| 602 | if (kIsDebugBuild) { |
| 603 | const uint16_t* table = mir_graph_->GetTable(mir, table_offset); |
| 604 | const Instruction::ArrayDataPayload* payload = |
| 605 | reinterpret_cast<const Instruction::ArrayDataPayload*>(table); |
| 606 | CHECK_EQ(payload->ident, static_cast<uint16_t>(Instruction::kArrayDataSignature)); |
| 607 | } |
| 608 | uint32_t table_offset_from_start = mir->offset + static_cast<int32_t>(table_offset); |
| 609 | CallRuntimeHelperImmRegLocation(kQuickHandleFillArrayData, table_offset_from_start, rl_src, true); |
| 610 | } |
| 611 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 612 | // |
| 613 | // Slow path to ensure a class is initialized for sget/sput. |
| 614 | // |
| 615 | class StaticFieldSlowPath : public Mir2Lir::LIRSlowPath { |
| 616 | public: |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 617 | // There are up to two branches to the static field slow path, the "unresolved" when the type |
| 618 | // entry in the dex cache is null, and the "uninit" when the class is not yet initialized. |
| 619 | // At least one will be non-null here, otherwise we wouldn't generate the slow path. |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 620 | StaticFieldSlowPath(Mir2Lir* m2l, LIR* unresolved, LIR* uninit, LIR* cont, int storage_index, |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 621 | RegStorage r_base) |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 622 | : LIRSlowPath(m2l, unresolved != nullptr ? unresolved : uninit, cont), |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 623 | second_branch_(unresolved != nullptr ? uninit : nullptr), |
| 624 | storage_index_(storage_index), r_base_(r_base) { |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | void Compile() { |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 628 | LIR* target = GenerateTargetLabel(); |
| 629 | if (second_branch_ != nullptr) { |
| 630 | second_branch_->target = target; |
| 631 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 632 | m2l_->CallRuntimeHelperImm(kQuickInitializeStaticStorage, storage_index_, true); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 633 | // Copy helper's result into r_base, a no-op on all but MIPS. |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 634 | m2l_->OpRegCopy(r_base_, m2l_->TargetReg(kRet0, kRef)); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 635 | |
| 636 | m2l_->OpUnconditionalBranch(cont_); |
| 637 | } |
| 638 | |
| 639 | private: |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 640 | // Second branch to the slow path, or null if there's only one branch. |
| 641 | LIR* const second_branch_; |
| 642 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 643 | const int storage_index_; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 644 | const RegStorage r_base_; |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 645 | }; |
| 646 | |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 647 | void Mir2Lir::GenSput(MIR* mir, RegLocation rl_src, OpSize size) { |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 648 | const MirSFieldLoweringInfo& field_info = mir_graph_->GetSFieldLoweringInfo(mir); |
Vladimir Marko | af6925b | 2014-10-31 16:37:32 +0000 | [diff] [blame] | 649 | DCHECK_EQ(SPutMemAccessType(mir->dalvikInsn.opcode), field_info.MemAccessType()); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 650 | cu_->compiler_driver->ProcessedStaticField(field_info.FastPut(), field_info.IsReferrersClass()); |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 651 | if (!ForceSlowFieldPath(cu_) && field_info.FastPut()) { |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 652 | DCHECK_GE(field_info.FieldOffset().Int32Value(), 0); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 653 | RegStorage r_base; |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 654 | if (field_info.IsReferrersClass()) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 655 | // Fast path, static storage base is this method's class |
Matteo Franchin | 0955f7e | 2014-05-23 17:32:52 +0100 | [diff] [blame] | 656 | RegLocation rl_method = LoadCurrMethod(); |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 657 | r_base = AllocTempRef(); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 658 | LoadRefDisp(rl_method.reg, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), r_base, |
| 659 | kNotVolatile); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 660 | if (IsTemp(rl_method.reg)) { |
| 661 | FreeTemp(rl_method.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 662 | } |
| 663 | } else { |
| 664 | // Medium path, static storage base in a different class which requires checks that the other |
| 665 | // class is initialized. |
| 666 | // TODO: remove initialized check now that we are initializing classes in the compiler driver. |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 667 | DCHECK_NE(field_info.StorageIndex(), DexFile::kDexNoIndex); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 668 | // May do runtime call so everything to home locations. |
| 669 | FlushAllRegs(); |
| 670 | // Using fixed register to sync with possible call to runtime support. |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 671 | RegStorage r_method = TargetReg(kArg1, kRef); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 672 | LockTemp(r_method); |
| 673 | LoadCurrMethodDirect(r_method); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 674 | r_base = TargetReg(kArg0, kRef); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 675 | LockTemp(r_base); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 676 | LoadRefDisp(r_method, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), r_base, |
| 677 | kNotVolatile); |
Andreas Gampe | 9c3b089 | 2014-04-24 17:33:34 +0000 | [diff] [blame] | 678 | int32_t offset_of_field = ObjArray::OffsetOfElement(field_info.StorageIndex()).Int32Value(); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 679 | LoadRefDisp(r_base, offset_of_field, r_base, kNotVolatile); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 680 | // r_base now points at static storage (Class*) or NULL if the type is not yet resolved. |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 681 | LIR* unresolved_branch = nullptr; |
| 682 | if (!field_info.IsClassInDexCache() && |
| 683 | (mir->optimization_flags & MIR_CLASS_IS_IN_DEX_CACHE) == 0) { |
| 684 | // Check if r_base is NULL. |
| 685 | unresolved_branch = OpCmpImmBranch(kCondEq, r_base, 0, NULL); |
| 686 | } |
| 687 | LIR* uninit_branch = nullptr; |
| 688 | if (!field_info.IsClassInitialized() && |
| 689 | (mir->optimization_flags & MIR_CLASS_IS_INITIALIZED) == 0) { |
| 690 | // Check if r_base is not yet initialized class. |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 691 | RegStorage r_tmp = TargetReg(kArg2, kNotWide); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 692 | LockTemp(r_tmp); |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 693 | uninit_branch = OpCmpMemImmBranch(kCondLt, r_tmp, r_base, |
Mark Mendell | 766e929 | 2014-01-27 07:55:47 -0800 | [diff] [blame] | 694 | mirror::Class::StatusOffset().Int32Value(), |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 695 | mirror::Class::kStatusInitialized, nullptr, nullptr); |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 696 | FreeTemp(r_tmp); |
| 697 | } |
| 698 | if (unresolved_branch != nullptr || uninit_branch != nullptr) { |
| 699 | // The slow path is invoked if the r_base is NULL or the class pointed |
| 700 | // to by it is not initialized. |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 701 | LIR* cont = NewLIR0(kPseudoTargetLabel); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 702 | AddSlowPath(new (arena_) StaticFieldSlowPath(this, unresolved_branch, uninit_branch, cont, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 703 | field_info.StorageIndex(), r_base)); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 704 | |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 705 | if (uninit_branch != nullptr) { |
| 706 | // Ensure load of status and store of value don't re-order. |
| 707 | // TODO: Presumably the actual value store is control-dependent on the status load, |
| 708 | // and will thus not be reordered in any case, since stores are never speculated. |
| 709 | // Does later code "know" that the class is now initialized? If so, we still |
| 710 | // need the barrier to guard later static loads. |
| 711 | GenMemBarrier(kLoadAny); |
| 712 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 713 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 714 | FreeTemp(r_method); |
| 715 | } |
| 716 | // rBase now holds static storage base |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 717 | RegisterClass reg_class = RegClassForFieldLoadStore(size, field_info.IsVolatile()); |
| 718 | if (IsWide(size)) { |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 719 | rl_src = LoadValueWide(rl_src, reg_class); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 720 | } else { |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 721 | rl_src = LoadValue(rl_src, reg_class); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 722 | } |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 723 | if (IsRef(size)) { |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 724 | StoreRefDisp(r_base, field_info.FieldOffset().Int32Value(), rl_src.reg, |
| 725 | field_info.IsVolatile() ? kVolatile : kNotVolatile); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 726 | } else { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 727 | StoreBaseDisp(r_base, field_info.FieldOffset().Int32Value(), rl_src.reg, size, |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 728 | field_info.IsVolatile() ? kVolatile : kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 729 | } |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 730 | if (IsRef(size) && !mir_graph_->IsConstantNullRef(rl_src)) { |
Vladimir Marko | 743b98c | 2014-11-24 19:45:41 +0000 | [diff] [blame] | 731 | MarkGCCard(mir->optimization_flags, rl_src.reg, r_base); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 732 | } |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 733 | FreeTemp(r_base); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 734 | } else { |
| 735 | FlushAllRegs(); // Everything to home locations |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 736 | QuickEntrypointEnum target; |
| 737 | switch (size) { |
| 738 | case kReference: |
| 739 | target = kQuickSetObjStatic; |
| 740 | break; |
| 741 | case k64: |
| 742 | case kDouble: |
| 743 | target = kQuickSet64Static; |
| 744 | break; |
| 745 | case k32: |
| 746 | case kSingle: |
| 747 | target = kQuickSet32Static; |
| 748 | break; |
| 749 | case kSignedHalf: |
| 750 | case kUnsignedHalf: |
| 751 | target = kQuickSet16Static; |
| 752 | break; |
| 753 | case kSignedByte: |
| 754 | case kUnsignedByte: |
| 755 | target = kQuickSet8Static; |
| 756 | break; |
| 757 | case kWord: // Intentional fallthrough. |
| 758 | default: |
| 759 | LOG(FATAL) << "Can't determine entrypoint for: " << size; |
| 760 | target = kQuickSet32Static; |
| 761 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 762 | CallRuntimeHelperImmRegLocation(target, field_info.FieldIndex(), rl_src, true); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 763 | } |
| 764 | } |
| 765 | |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 766 | void Mir2Lir::GenSget(MIR* mir, RegLocation rl_dest, OpSize size, Primitive::Type type) { |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 767 | const MirSFieldLoweringInfo& field_info = mir_graph_->GetSFieldLoweringInfo(mir); |
Vladimir Marko | af6925b | 2014-10-31 16:37:32 +0000 | [diff] [blame] | 768 | DCHECK_EQ(SGetMemAccessType(mir->dalvikInsn.opcode), field_info.MemAccessType()); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 769 | cu_->compiler_driver->ProcessedStaticField(field_info.FastGet(), field_info.IsReferrersClass()); |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 770 | |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 771 | if (!ForceSlowFieldPath(cu_) && field_info.FastGet()) { |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 772 | DCHECK_GE(field_info.FieldOffset().Int32Value(), 0); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 773 | RegStorage r_base; |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 774 | if (field_info.IsReferrersClass()) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 775 | // Fast path, static storage base is this method's class |
| 776 | RegLocation rl_method = LoadCurrMethod(); |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 777 | r_base = AllocTempRef(); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 778 | LoadRefDisp(rl_method.reg, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), r_base, |
| 779 | kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 780 | } else { |
| 781 | // Medium path, static storage base in a different class which requires checks that the other |
| 782 | // class is initialized |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 783 | DCHECK_NE(field_info.StorageIndex(), DexFile::kDexNoIndex); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 784 | // May do runtime call so everything to home locations. |
| 785 | FlushAllRegs(); |
| 786 | // Using fixed register to sync with possible call to runtime support. |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 787 | RegStorage r_method = TargetReg(kArg1, kRef); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 788 | LockTemp(r_method); |
| 789 | LoadCurrMethodDirect(r_method); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 790 | r_base = TargetReg(kArg0, kRef); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 791 | LockTemp(r_base); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 792 | LoadRefDisp(r_method, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), r_base, |
| 793 | kNotVolatile); |
Andreas Gampe | 9c3b089 | 2014-04-24 17:33:34 +0000 | [diff] [blame] | 794 | int32_t offset_of_field = ObjArray::OffsetOfElement(field_info.StorageIndex()).Int32Value(); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 795 | LoadRefDisp(r_base, offset_of_field, r_base, kNotVolatile); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 796 | // r_base now points at static storage (Class*) or NULL if the type is not yet resolved. |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 797 | LIR* unresolved_branch = nullptr; |
| 798 | if (!field_info.IsClassInDexCache() && |
| 799 | (mir->optimization_flags & MIR_CLASS_IS_IN_DEX_CACHE) == 0) { |
| 800 | // Check if r_base is NULL. |
| 801 | unresolved_branch = OpCmpImmBranch(kCondEq, r_base, 0, NULL); |
| 802 | } |
| 803 | LIR* uninit_branch = nullptr; |
| 804 | if (!field_info.IsClassInitialized() && |
| 805 | (mir->optimization_flags & MIR_CLASS_IS_INITIALIZED) == 0) { |
| 806 | // Check if r_base is not yet initialized class. |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 807 | RegStorage r_tmp = TargetReg(kArg2, kNotWide); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 808 | LockTemp(r_tmp); |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 809 | uninit_branch = OpCmpMemImmBranch(kCondLt, r_tmp, r_base, |
Mark Mendell | 766e929 | 2014-01-27 07:55:47 -0800 | [diff] [blame] | 810 | mirror::Class::StatusOffset().Int32Value(), |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 811 | mirror::Class::kStatusInitialized, nullptr, nullptr); |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 812 | FreeTemp(r_tmp); |
| 813 | } |
| 814 | if (unresolved_branch != nullptr || uninit_branch != nullptr) { |
| 815 | // The slow path is invoked if the r_base is NULL or the class pointed |
| 816 | // to by it is not initialized. |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 817 | LIR* cont = NewLIR0(kPseudoTargetLabel); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 818 | AddSlowPath(new (arena_) StaticFieldSlowPath(this, unresolved_branch, uninit_branch, cont, |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 819 | field_info.StorageIndex(), r_base)); |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 820 | |
Vladimir Marko | 66c6d7b | 2014-10-16 15:41:48 +0100 | [diff] [blame] | 821 | if (uninit_branch != nullptr) { |
| 822 | // Ensure load of status and load of value don't re-order. |
| 823 | GenMemBarrier(kLoadAny); |
| 824 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 825 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 826 | FreeTemp(r_method); |
| 827 | } |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 828 | // r_base now holds static storage base |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 829 | RegisterClass reg_class = RegClassForFieldLoadStore(size, field_info.IsVolatile()); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 830 | RegLocation rl_result = EvalLoc(rl_dest, reg_class, true); |
Razvan A Lupusoru | 99ad723 | 2014-02-25 17:41:08 -0800 | [diff] [blame] | 831 | |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 832 | int field_offset = field_info.FieldOffset().Int32Value(); |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 833 | if (IsRef(size)) { |
| 834 | // TODO: DCHECK? |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 835 | LoadRefDisp(r_base, field_offset, rl_result.reg, field_info.IsVolatile() ? kVolatile : |
| 836 | kNotVolatile); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 837 | } else { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 838 | LoadBaseDisp(r_base, field_offset, rl_result.reg, size, field_info.IsVolatile() ? |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 839 | kVolatile : kNotVolatile); |
Razvan A Lupusoru | 99ad723 | 2014-02-25 17:41:08 -0800 | [diff] [blame] | 840 | } |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 841 | FreeTemp(r_base); |
Razvan A Lupusoru | 99ad723 | 2014-02-25 17:41:08 -0800 | [diff] [blame] | 842 | |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 843 | if (IsWide(size)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 844 | StoreValueWide(rl_dest, rl_result); |
| 845 | } else { |
| 846 | StoreValue(rl_dest, rl_result); |
| 847 | } |
| 848 | } else { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 849 | DCHECK(SizeMatchesTypeForEntrypoint(size, type)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 850 | FlushAllRegs(); // Everything to home locations |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 851 | QuickEntrypointEnum target; |
| 852 | switch (type) { |
| 853 | case Primitive::kPrimNot: |
| 854 | target = kQuickGetObjStatic; |
| 855 | break; |
| 856 | case Primitive::kPrimLong: |
| 857 | case Primitive::kPrimDouble: |
| 858 | target = kQuickGet64Static; |
| 859 | break; |
| 860 | case Primitive::kPrimInt: |
| 861 | case Primitive::kPrimFloat: |
| 862 | target = kQuickGet32Static; |
| 863 | break; |
| 864 | case Primitive::kPrimShort: |
| 865 | target = kQuickGetShortStatic; |
| 866 | break; |
| 867 | case Primitive::kPrimChar: |
| 868 | target = kQuickGetCharStatic; |
| 869 | break; |
| 870 | case Primitive::kPrimByte: |
| 871 | target = kQuickGetByteStatic; |
| 872 | break; |
| 873 | case Primitive::kPrimBoolean: |
| 874 | target = kQuickGetBooleanStatic; |
| 875 | break; |
| 876 | case Primitive::kPrimVoid: // Intentional fallthrough. |
| 877 | default: |
| 878 | LOG(FATAL) << "Can't determine entrypoint for: " << type; |
| 879 | target = kQuickGet32Static; |
| 880 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 881 | CallRuntimeHelperImm(target, field_info.FieldIndex(), true); |
| 882 | |
Douglas Leung | 2db3e26 | 2014-06-25 16:02:55 -0700 | [diff] [blame] | 883 | // FIXME: pGetXXStatic always return an int or int64 regardless of rl_dest.fp. |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 884 | if (IsWide(size)) { |
Douglas Leung | 2db3e26 | 2014-06-25 16:02:55 -0700 | [diff] [blame] | 885 | RegLocation rl_result = GetReturnWide(kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 886 | StoreValueWide(rl_dest, rl_result); |
| 887 | } else { |
Douglas Leung | 2db3e26 | 2014-06-25 16:02:55 -0700 | [diff] [blame] | 888 | RegLocation rl_result = GetReturn(rl_dest.ref ? kRefReg : kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 889 | StoreValue(rl_dest, rl_result); |
| 890 | } |
| 891 | } |
| 892 | } |
| 893 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 894 | // Generate code for all slow paths. |
| 895 | void Mir2Lir::HandleSlowPaths() { |
Chao-ying Fu | 8159af6 | 2014-07-07 17:13:52 -0700 | [diff] [blame] | 896 | // We should check slow_paths_.Size() every time, because a new slow path |
| 897 | // may be created during slowpath->Compile(). |
Vladimir Marko | e39c54e | 2014-09-22 14:50:02 +0100 | [diff] [blame] | 898 | for (LIRSlowPath* slowpath : slow_paths_) { |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 899 | slowpath->Compile(); |
| 900 | } |
Vladimir Marko | e39c54e | 2014-09-22 14:50:02 +0100 | [diff] [blame] | 901 | slow_paths_.clear(); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 902 | } |
| 903 | |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 904 | void Mir2Lir::GenIGet(MIR* mir, int opt_flags, OpSize size, Primitive::Type type, |
| 905 | RegLocation rl_dest, RegLocation rl_obj) { |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 906 | const MirIFieldLoweringInfo& field_info = mir_graph_->GetIFieldLoweringInfo(mir); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 907 | if (kIsDebugBuild) { |
| 908 | auto mem_access_type = IsInstructionIGetQuickOrIPutQuick(mir->dalvikInsn.opcode) ? |
| 909 | IGetQuickOrIPutQuickMemAccessType(mir->dalvikInsn.opcode) : |
| 910 | IGetMemAccessType(mir->dalvikInsn.opcode); |
| 911 | DCHECK_EQ(mem_access_type, field_info.MemAccessType()) << mir->dalvikInsn.opcode; |
| 912 | } |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 913 | cu_->compiler_driver->ProcessedInstanceField(field_info.FastGet()); |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 914 | if (!ForceSlowFieldPath(cu_) && field_info.FastGet()) { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 915 | RegisterClass reg_class = RegClassForFieldLoadStore(size, field_info.IsVolatile()); |
Andreas Gampe | aa910d5 | 2014-07-30 18:59:05 -0700 | [diff] [blame] | 916 | // A load of the class will lead to an iget with offset 0. |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 917 | DCHECK_GE(field_info.FieldOffset().Int32Value(), 0); |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 918 | rl_obj = LoadValue(rl_obj, kRefReg); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 919 | GenNullCheck(rl_obj.reg, opt_flags); |
| 920 | RegLocation rl_result = EvalLoc(rl_dest, reg_class, true); |
| 921 | int field_offset = field_info.FieldOffset().Int32Value(); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 922 | LIR* load_lir; |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 923 | if (IsRef(size)) { |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 924 | load_lir = LoadRefDisp(rl_obj.reg, field_offset, rl_result.reg, field_info.IsVolatile() ? |
| 925 | kVolatile : kNotVolatile); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 926 | } else { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 927 | load_lir = LoadBaseDisp(rl_obj.reg, field_offset, rl_result.reg, size, |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 928 | field_info.IsVolatile() ? kVolatile : kNotVolatile); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 929 | } |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 930 | MarkPossibleNullPointerExceptionAfter(opt_flags, load_lir); |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 931 | if (IsWide(size)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 932 | StoreValueWide(rl_dest, rl_result); |
| 933 | } else { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 934 | StoreValue(rl_dest, rl_result); |
| 935 | } |
| 936 | } else { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 937 | DCHECK(SizeMatchesTypeForEntrypoint(size, type)); |
| 938 | QuickEntrypointEnum target; |
| 939 | switch (type) { |
| 940 | case Primitive::kPrimNot: |
| 941 | target = kQuickGetObjInstance; |
| 942 | break; |
| 943 | case Primitive::kPrimLong: |
| 944 | case Primitive::kPrimDouble: |
| 945 | target = kQuickGet64Instance; |
| 946 | break; |
| 947 | case Primitive::kPrimFloat: |
| 948 | case Primitive::kPrimInt: |
| 949 | target = kQuickGet32Instance; |
| 950 | break; |
| 951 | case Primitive::kPrimShort: |
| 952 | target = kQuickGetShortInstance; |
| 953 | break; |
| 954 | case Primitive::kPrimChar: |
| 955 | target = kQuickGetCharInstance; |
| 956 | break; |
| 957 | case Primitive::kPrimByte: |
| 958 | target = kQuickGetByteInstance; |
| 959 | break; |
| 960 | case Primitive::kPrimBoolean: |
| 961 | target = kQuickGetBooleanInstance; |
| 962 | break; |
| 963 | case Primitive::kPrimVoid: // Intentional fallthrough. |
| 964 | default: |
| 965 | LOG(FATAL) << "Can't determine entrypoint for: " << type; |
| 966 | target = kQuickGet32Instance; |
| 967 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 968 | // Second argument of pGetXXInstance is always a reference. |
| 969 | DCHECK_EQ(static_cast<unsigned int>(rl_obj.wide), 0U); |
| 970 | CallRuntimeHelperImmRegLocation(target, field_info.FieldIndex(), rl_obj, true); |
| 971 | |
Serguei Katkov | 4eca9f5 | 2014-07-08 00:45:45 +0700 | [diff] [blame] | 972 | // FIXME: pGetXXInstance always return an int or int64 regardless of rl_dest.fp. |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 973 | if (IsWide(size)) { |
Serguei Katkov | 4eca9f5 | 2014-07-08 00:45:45 +0700 | [diff] [blame] | 974 | RegLocation rl_result = GetReturnWide(kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 975 | StoreValueWide(rl_dest, rl_result); |
| 976 | } else { |
Serguei Katkov | 4eca9f5 | 2014-07-08 00:45:45 +0700 | [diff] [blame] | 977 | RegLocation rl_result = GetReturn(rl_dest.ref ? kRefReg : kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 978 | StoreValue(rl_dest, rl_result); |
| 979 | } |
| 980 | } |
| 981 | } |
| 982 | |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 983 | void Mir2Lir::GenIPut(MIR* mir, int opt_flags, OpSize size, |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 984 | RegLocation rl_src, RegLocation rl_obj) { |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 985 | const MirIFieldLoweringInfo& field_info = mir_graph_->GetIFieldLoweringInfo(mir); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 986 | if (kIsDebugBuild) { |
| 987 | auto mem_access_type = IsInstructionIGetQuickOrIPutQuick(mir->dalvikInsn.opcode) ? |
| 988 | IGetQuickOrIPutQuickMemAccessType(mir->dalvikInsn.opcode) : |
| 989 | IPutMemAccessType(mir->dalvikInsn.opcode); |
| 990 | DCHECK_EQ(mem_access_type, field_info.MemAccessType()); |
| 991 | } |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 992 | cu_->compiler_driver->ProcessedInstanceField(field_info.FastPut()); |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 993 | if (!ForceSlowFieldPath(cu_) && field_info.FastPut()) { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 994 | RegisterClass reg_class = RegClassForFieldLoadStore(size, field_info.IsVolatile()); |
Andreas Gampe | aa910d5 | 2014-07-30 18:59:05 -0700 | [diff] [blame] | 995 | // Dex code never writes to the class field. |
| 996 | DCHECK_GE(static_cast<uint32_t>(field_info.FieldOffset().Int32Value()), |
| 997 | sizeof(mirror::HeapReference<mirror::Class>)); |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 998 | rl_obj = LoadValue(rl_obj, kRefReg); |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 999 | if (IsWide(size)) { |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 1000 | rl_src = LoadValueWide(rl_src, reg_class); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1001 | } else { |
| 1002 | rl_src = LoadValue(rl_src, reg_class); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 1003 | } |
| 1004 | GenNullCheck(rl_obj.reg, opt_flags); |
| 1005 | int field_offset = field_info.FieldOffset().Int32Value(); |
Vladimir Marko | ee5e273 | 2015-01-13 17:34:28 +0000 | [diff] [blame] | 1006 | LIR* null_ck_insn; |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 1007 | if (IsRef(size)) { |
Vladimir Marko | ee5e273 | 2015-01-13 17:34:28 +0000 | [diff] [blame] | 1008 | null_ck_insn = StoreRefDisp(rl_obj.reg, field_offset, rl_src.reg, field_info.IsVolatile() ? |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 1009 | kVolatile : kNotVolatile); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 1010 | } else { |
Vladimir Marko | ee5e273 | 2015-01-13 17:34:28 +0000 | [diff] [blame] | 1011 | null_ck_insn = StoreBaseDisp(rl_obj.reg, field_offset, rl_src.reg, size, |
| 1012 | field_info.IsVolatile() ? kVolatile : kNotVolatile); |
Vladimir Marko | 674744e | 2014-04-24 15:18:26 +0100 | [diff] [blame] | 1013 | } |
Vladimir Marko | ee5e273 | 2015-01-13 17:34:28 +0000 | [diff] [blame] | 1014 | MarkPossibleNullPointerExceptionAfter(opt_flags, null_ck_insn); |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 1015 | if (IsRef(size) && !mir_graph_->IsConstantNullRef(rl_src)) { |
Vladimir Marko | 743b98c | 2014-11-24 19:45:41 +0000 | [diff] [blame] | 1016 | MarkGCCard(opt_flags, rl_src.reg, rl_obj.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1017 | } |
| 1018 | } else { |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 1019 | QuickEntrypointEnum target; |
| 1020 | switch (size) { |
| 1021 | case kReference: |
| 1022 | target = kQuickSetObjInstance; |
| 1023 | break; |
| 1024 | case k64: |
| 1025 | case kDouble: |
| 1026 | target = kQuickSet64Instance; |
| 1027 | break; |
| 1028 | case k32: |
| 1029 | case kSingle: |
| 1030 | target = kQuickSet32Instance; |
| 1031 | break; |
| 1032 | case kSignedHalf: |
| 1033 | case kUnsignedHalf: |
| 1034 | target = kQuickSet16Instance; |
| 1035 | break; |
| 1036 | case kSignedByte: |
| 1037 | case kUnsignedByte: |
| 1038 | target = kQuickSet8Instance; |
| 1039 | break; |
| 1040 | case kWord: // Intentional fallthrough. |
| 1041 | default: |
| 1042 | LOG(FATAL) << "Can't determine entrypoint for: " << size; |
| 1043 | target = kQuickSet32Instance; |
| 1044 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1045 | CallRuntimeHelperImmRegLocationRegLocation(target, field_info.FieldIndex(), rl_obj, rl_src, |
| 1046 | true); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1047 | } |
| 1048 | } |
| 1049 | |
Ian Rogers | a9a8254 | 2013-10-04 11:17:26 -0700 | [diff] [blame] | 1050 | void Mir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array, RegLocation rl_index, |
| 1051 | RegLocation rl_src) { |
| 1052 | bool needs_range_check = !(opt_flags & MIR_IGNORE_RANGE_CHECK); |
| 1053 | bool needs_null_check = !((cu_->disable_opt & (1 << kNullCheckElimination)) && |
| 1054 | (opt_flags & MIR_IGNORE_NULL_CHECK)); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1055 | QuickEntrypointEnum target = needs_range_check |
| 1056 | ? (needs_null_check ? kQuickAputObjectWithNullAndBoundCheck |
| 1057 | : kQuickAputObjectWithBoundCheck) |
| 1058 | : kQuickAputObject; |
| 1059 | CallRuntimeHelperRegLocationRegLocationRegLocation(target, rl_array, rl_index, rl_src, true); |
Ian Rogers | a9a8254 | 2013-10-04 11:17:26 -0700 | [diff] [blame] | 1060 | } |
| 1061 | |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1062 | void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest) { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1063 | RegLocation rl_result; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1064 | if (!cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, |
Andreas Gampe | 4b537a8 | 2014-06-30 22:24:53 -0700 | [diff] [blame] | 1065 | *cu_->dex_file, |
| 1066 | type_idx)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1067 | // Call out to helper which resolves type and verifies access. |
| 1068 | // Resolved type returned in kRet0. |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1069 | CallRuntimeHelperImmMethod(kQuickInitializeTypeAndVerifyAccess, type_idx, true); |
| 1070 | rl_result = GetReturn(kRefReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1071 | } else { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1072 | rl_result = EvalLoc(rl_dest, kRefReg, true); |
| 1073 | // We don't need access checks, load type from dex cache |
| 1074 | RegStorage r_method = RegStorage::InvalidReg(); |
| 1075 | if (CanUseOpPcRelDexCacheArrayLoad()) { |
| 1076 | size_t offset = dex_cache_arrays_layout_.TypeOffset(type_idx); |
| 1077 | OpPcRelDexCacheArrayLoad(cu_->dex_file, offset, rl_result.reg); |
| 1078 | } else { |
| 1079 | RegLocation rl_method = LoadCurrMethod(); |
| 1080 | CheckRegLocation(rl_method); |
| 1081 | r_method = rl_method.reg; |
| 1082 | int32_t dex_cache_offset = |
| 1083 | mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(); |
| 1084 | RegStorage res_reg = AllocTempRef(); |
| 1085 | LoadRefDisp(r_method, dex_cache_offset, res_reg, kNotVolatile); |
| 1086 | int32_t offset_of_type = ClassArray::OffsetOfElement(type_idx).Int32Value(); |
| 1087 | LoadRefDisp(res_reg, offset_of_type, rl_result.reg, kNotVolatile); |
| 1088 | FreeTemp(res_reg); |
| 1089 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1090 | if (!cu_->compiler_driver->CanAssumeTypeIsPresentInDexCache(*cu_->dex_file, |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 1091 | type_idx) || ForceSlowTypePath(cu_)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1092 | // Slow path, at runtime test if type is null and if so initialize |
| 1093 | FlushAllRegs(); |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1094 | GenIfNullUseHelperImmMethod(rl_result.reg, kQuickInitializeType, type_idx, r_method); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1095 | } |
| 1096 | } |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1097 | StoreValue(rl_dest, rl_result); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1098 | } |
| 1099 | |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1100 | void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1101 | /* NOTE: Most strings should be available at compile time */ |
Andreas Gampe | 9c3b089 | 2014-04-24 17:33:34 +0000 | [diff] [blame] | 1102 | int32_t offset_of_string = mirror::ObjectArray<mirror::String>::OffsetOfElement(string_idx). |
| 1103 | Int32Value(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1104 | if (!cu_->compiler_driver->CanAssumeStringIsPresentInDexCache( |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 1105 | *cu_->dex_file, string_idx) || ForceSlowStringPath(cu_)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1106 | // slow path, resolve string if not in dex cache |
| 1107 | FlushAllRegs(); |
Brian Carlstrom | 7934ac2 | 2013-07-26 10:54:15 -0700 | [diff] [blame] | 1108 | LockCallTemps(); // Using explicit registers |
Mark Mendell | 766e929 | 2014-01-27 07:55:47 -0800 | [diff] [blame] | 1109 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1110 | // Might call out to helper, which will return resolved string in kRet0 |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1111 | RegStorage ret0 = TargetReg(kRet0, kRef); |
| 1112 | RegStorage r_method = RegStorage::InvalidReg(); |
| 1113 | if (CanUseOpPcRelDexCacheArrayLoad()) { |
| 1114 | size_t offset = dex_cache_arrays_layout_.StringOffset(string_idx); |
| 1115 | OpPcRelDexCacheArrayLoad(cu_->dex_file, offset, ret0); |
| 1116 | } else { |
| 1117 | r_method = LoadCurrMethodWithHint(TargetReg(kArg1, kRef)); |
| 1118 | // Method to declaring class. |
| 1119 | RegStorage arg0 = TargetReg(kArg0, kRef); |
| 1120 | LoadRefDisp(r_method, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), |
| 1121 | arg0, kNotVolatile); |
| 1122 | // Declaring class to dex cache strings. |
| 1123 | LoadRefDisp(arg0, mirror::Class::DexCacheStringsOffset().Int32Value(), arg0, kNotVolatile); |
Mark Mendell | 766e929 | 2014-01-27 07:55:47 -0800 | [diff] [blame] | 1124 | |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1125 | LoadRefDisp(arg0, offset_of_string, ret0, kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1126 | } |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1127 | GenIfNullUseHelperImmMethod(ret0, kQuickResolveString, string_idx, r_method); |
Mingyao Yang | 3b004ba | 2014-04-29 15:55:37 -0700 | [diff] [blame] | 1128 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1129 | GenBarrier(); |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1130 | StoreValue(rl_dest, GetReturn(kRefReg)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1131 | } else { |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1132 | RegLocation rl_result = EvalLoc(rl_dest, kRefReg, true); |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1133 | if (CanUseOpPcRelDexCacheArrayLoad()) { |
| 1134 | size_t offset = dex_cache_arrays_layout_.StringOffset(string_idx); |
| 1135 | OpPcRelDexCacheArrayLoad(cu_->dex_file, offset, rl_result.reg); |
| 1136 | } else { |
| 1137 | RegLocation rl_method = LoadCurrMethod(); |
| 1138 | RegStorage res_reg = AllocTempRef(); |
| 1139 | LoadRefDisp(rl_method.reg, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), res_reg, |
| 1140 | kNotVolatile); |
| 1141 | LoadRefDisp(res_reg, mirror::Class::DexCacheStringsOffset().Int32Value(), res_reg, |
| 1142 | kNotVolatile); |
| 1143 | LoadRefDisp(res_reg, offset_of_string, rl_result.reg, kNotVolatile); |
| 1144 | FreeTemp(res_reg); |
| 1145 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1146 | StoreValue(rl_dest, rl_result); |
| 1147 | } |
| 1148 | } |
| 1149 | |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1150 | /* |
| 1151 | * Let helper function take care of everything. Will |
| 1152 | * call Class::NewInstanceFromCode(type_idx, method); |
| 1153 | */ |
| 1154 | void Mir2Lir::GenNewInstance(uint32_t type_idx, RegLocation rl_dest) { |
| 1155 | FlushAllRegs(); /* Everything to home location */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1156 | // alloc will always check for resolution, do we also need to verify |
| 1157 | // access because the verifier was unable to? |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1158 | const DexFile* dex_file = cu_->dex_file; |
| 1159 | CompilerDriver* driver = cu_->compiler_driver; |
| 1160 | if (driver->CanAccessInstantiableTypeWithoutChecks(cu_->method_idx, *dex_file, type_idx)) { |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1161 | bool is_type_initialized; |
| 1162 | bool use_direct_type_ptr; |
| 1163 | uintptr_t direct_type_ptr; |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 1164 | bool is_finalizable; |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1165 | if (kEmbedClassInCode && |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 1166 | driver->CanEmbedTypeInCode(*dex_file, type_idx, &is_type_initialized, &use_direct_type_ptr, |
| 1167 | &direct_type_ptr, &is_finalizable) && |
| 1168 | !is_finalizable) { |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1169 | // The fast path. |
| 1170 | if (!use_direct_type_ptr) { |
Fred Shih | e7f82e2 | 2014-08-06 10:46:37 -0700 | [diff] [blame] | 1171 | LoadClassType(*dex_file, type_idx, kArg0); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1172 | if (!is_type_initialized) { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1173 | CallRuntimeHelperRegMethod(kQuickAllocObjectResolved, TargetReg(kArg0, kRef), true); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1174 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1175 | CallRuntimeHelperRegMethod(kQuickAllocObjectInitialized, TargetReg(kArg0, kRef), true); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1176 | } |
| 1177 | } else { |
| 1178 | // Use the direct pointer. |
| 1179 | if (!is_type_initialized) { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1180 | CallRuntimeHelperImmMethod(kQuickAllocObjectResolved, direct_type_ptr, true); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1181 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1182 | CallRuntimeHelperImmMethod(kQuickAllocObjectInitialized, direct_type_ptr, true); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1183 | } |
| 1184 | } |
| 1185 | } else { |
| 1186 | // The slow path. |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1187 | CallRuntimeHelperImmMethod(kQuickAllocObject, type_idx, true); |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1188 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1189 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1190 | CallRuntimeHelperImmMethod(kQuickAllocObjectWithAccessCheck, type_idx, true); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1191 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1192 | StoreValue(rl_dest, GetReturn(kRefReg)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1193 | } |
| 1194 | |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1195 | void Mir2Lir::GenThrow(RegLocation rl_src) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1196 | FlushAllRegs(); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1197 | CallRuntimeHelperRegLocation(kQuickDeliverException, rl_src, true); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1198 | } |
| 1199 | |
| 1200 | // For final classes there are no sub-classes to check and so we can answer the instance-of |
| 1201 | // question with simple comparisons. |
| 1202 | void Mir2Lir::GenInstanceofFinal(bool use_declaring_class, uint32_t type_idx, RegLocation rl_dest, |
| 1203 | RegLocation rl_src) { |
Mark Mendell | df8ee2e | 2014-01-27 16:37:47 -0800 | [diff] [blame] | 1204 | // X86 has its own implementation. |
Dmitry Petrochenko | 6a58cb1 | 2014-04-02 17:27:59 +0700 | [diff] [blame] | 1205 | DCHECK(cu_->instruction_set != kX86 && cu_->instruction_set != kX86_64); |
Mark Mendell | df8ee2e | 2014-01-27 16:37:47 -0800 | [diff] [blame] | 1206 | |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1207 | RegLocation object = LoadValue(rl_src, kRefReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1208 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1209 | RegStorage result_reg = rl_result.reg; |
buzbee | b5860fb | 2014-06-21 15:31:01 -0700 | [diff] [blame] | 1210 | if (IsSameReg(result_reg, object.reg)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1211 | result_reg = AllocTypedTemp(false, kCoreReg); |
buzbee | b5860fb | 2014-06-21 15:31:01 -0700 | [diff] [blame] | 1212 | DCHECK(!IsSameReg(result_reg, object.reg)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1213 | } |
| 1214 | LoadConstant(result_reg, 0); // assume false |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1215 | LIR* null_branchover = OpCmpImmBranch(kCondEq, object.reg, 0, NULL); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1216 | |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1217 | RegStorage check_class = AllocTypedTemp(false, kRefReg); |
| 1218 | RegStorage object_class = AllocTypedTemp(false, kRefReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1219 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1220 | if (use_declaring_class) { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1221 | RegStorage r_method = LoadCurrMethodWithHint(check_class); |
| 1222 | LoadRefDisp(r_method, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), check_class, |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 1223 | kNotVolatile); |
| 1224 | LoadRefDisp(object.reg, mirror::Object::ClassOffset().Int32Value(), object_class, |
| 1225 | kNotVolatile); |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1226 | } else if (CanUseOpPcRelDexCacheArrayLoad()) { |
| 1227 | size_t offset = dex_cache_arrays_layout_.TypeOffset(type_idx); |
| 1228 | OpPcRelDexCacheArrayLoad(cu_->dex_file, offset, check_class); |
| 1229 | LoadRefDisp(object.reg, mirror::Object::ClassOffset().Int32Value(), object_class, |
| 1230 | kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1231 | } else { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1232 | RegStorage r_method = LoadCurrMethodWithHint(check_class); |
| 1233 | LoadRefDisp(r_method, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 1234 | check_class, kNotVolatile); |
| 1235 | LoadRefDisp(object.reg, mirror::Object::ClassOffset().Int32Value(), object_class, |
| 1236 | kNotVolatile); |
Andreas Gampe | 9c3b089 | 2014-04-24 17:33:34 +0000 | [diff] [blame] | 1237 | int32_t offset_of_type = ClassArray::OffsetOfElement(type_idx).Int32Value(); |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 1238 | LoadRefDisp(check_class, offset_of_type, check_class, kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1239 | } |
| 1240 | |
buzbee | 695d13a | 2014-04-19 13:32:20 -0700 | [diff] [blame] | 1241 | // FIXME: what should we be comparing here? compressed or decompressed references? |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1242 | if (cu_->instruction_set == kThumb2) { |
| 1243 | OpRegReg(kOpCmp, check_class, object_class); // Same? |
Dave Allison | 3da67a5 | 2014-04-02 17:03:45 -0700 | [diff] [blame] | 1244 | LIR* it = OpIT(kCondEq, ""); // if-convert the test |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1245 | LoadConstant(result_reg, 1); // .eq case - load true |
Dave Allison | 3da67a5 | 2014-04-02 17:03:45 -0700 | [diff] [blame] | 1246 | OpEndIT(it); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1247 | } else { |
Andreas Gampe | 90969af | 2014-07-15 23:02:11 -0700 | [diff] [blame] | 1248 | GenSelectConst32(check_class, object_class, kCondEq, 1, 0, result_reg, kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1249 | } |
| 1250 | LIR* target = NewLIR0(kPseudoTargetLabel); |
| 1251 | null_branchover->target = target; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1252 | FreeTemp(object_class); |
| 1253 | FreeTemp(check_class); |
| 1254 | if (IsTemp(result_reg)) { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1255 | OpRegCopy(rl_result.reg, result_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1256 | FreeTemp(result_reg); |
| 1257 | } |
| 1258 | StoreValue(rl_dest, rl_result); |
| 1259 | } |
| 1260 | |
| 1261 | void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_known_final, |
| 1262 | bool type_known_abstract, bool use_declaring_class, |
| 1263 | bool can_assume_type_is_in_dex_cache, |
| 1264 | uint32_t type_idx, RegLocation rl_dest, |
| 1265 | RegLocation rl_src) { |
| 1266 | FlushAllRegs(); |
| 1267 | // May generate a call - use explicit registers |
| 1268 | LockCallTemps(); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1269 | RegStorage class_reg = TargetReg(kArg2, kRef); // kArg2 will hold the Class* |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1270 | RegStorage ref_reg = TargetReg(kArg0, kRef); // kArg0 will hold the ref. |
| 1271 | RegStorage ret_reg = GetReturn(kRefReg).reg; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1272 | if (needs_access_check) { |
| 1273 | // Check we have access to type_idx and if not throw IllegalAccessError, |
| 1274 | // returns Class* in kArg0 |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1275 | CallRuntimeHelperImmMethod(kQuickInitializeTypeAndVerifyAccess, type_idx, true); |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1276 | OpRegCopy(class_reg, ret_reg); // Align usage with fast path |
| 1277 | LoadValueDirectFixed(rl_src, ref_reg); // kArg0 <= ref |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1278 | } else if (use_declaring_class) { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1279 | RegStorage r_method = LoadCurrMethodWithHint(TargetReg(kArg1, kRef)); |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1280 | LoadValueDirectFixed(rl_src, ref_reg); // kArg0 <= ref |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1281 | LoadRefDisp(r_method, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 1282 | class_reg, kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1283 | } else { |
Andreas Gampe | 90969af | 2014-07-15 23:02:11 -0700 | [diff] [blame] | 1284 | if (can_assume_type_is_in_dex_cache) { |
| 1285 | // Conditionally, as in the other case we will also load it. |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1286 | LoadValueDirectFixed(rl_src, ref_reg); // kArg0 <= ref |
Andreas Gampe | 90969af | 2014-07-15 23:02:11 -0700 | [diff] [blame] | 1287 | } |
| 1288 | |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1289 | RegStorage r_method = RegStorage::InvalidReg(); |
| 1290 | if (CanUseOpPcRelDexCacheArrayLoad()) { |
| 1291 | size_t offset = dex_cache_arrays_layout_.TypeOffset(type_idx); |
| 1292 | OpPcRelDexCacheArrayLoad(cu_->dex_file, offset, class_reg); |
| 1293 | } else { |
| 1294 | r_method = LoadCurrMethodWithHint(TargetReg(kArg1, kRef)); |
| 1295 | // Load dex cache entry into class_reg (kArg2) |
| 1296 | LoadRefDisp(r_method, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), |
| 1297 | class_reg, kNotVolatile); |
| 1298 | int32_t offset_of_type = ClassArray::OffsetOfElement(type_idx).Int32Value(); |
| 1299 | LoadRefDisp(class_reg, offset_of_type, class_reg, kNotVolatile); |
| 1300 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1301 | if (!can_assume_type_is_in_dex_cache) { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1302 | GenIfNullUseHelperImmMethod(class_reg, kQuickInitializeType, type_idx, r_method); |
Andreas Gampe | 90969af | 2014-07-15 23:02:11 -0700 | [diff] [blame] | 1303 | |
| 1304 | // Should load value here. |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1305 | LoadValueDirectFixed(rl_src, ref_reg); // kArg0 <= ref |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1306 | } |
| 1307 | } |
| 1308 | /* kArg0 is ref, kArg2 is class. If ref==null, use directly as bool result */ |
Andreas Gampe | 4b537a8 | 2014-06-30 22:24:53 -0700 | [diff] [blame] | 1309 | RegLocation rl_result = GetReturn(kCoreReg); |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1310 | if (!IsSameReg(rl_result.reg, ref_reg)) { |
| 1311 | // On MIPS and x86_64 rArg0 != rl_result, place false in result if branch is taken. |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1312 | LoadConstant(rl_result.reg, 0); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1313 | } |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1314 | LIR* branch1 = OpCmpImmBranch(kCondEq, ref_reg, 0, NULL); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1315 | |
| 1316 | /* load object->klass_ */ |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1317 | RegStorage ref_class_reg = TargetReg(kArg1, kRef); // kArg1 will hold the Class* of ref. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1318 | DCHECK_EQ(mirror::Object::ClassOffset().Int32Value(), 0); |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1319 | LoadRefDisp(ref_reg, mirror::Object::ClassOffset().Int32Value(), |
| 1320 | ref_class_reg, kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1321 | /* kArg0 is ref, kArg1 is ref->klass_, kArg2 is class */ |
| 1322 | LIR* branchover = NULL; |
| 1323 | if (type_known_final) { |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1324 | // rl_result == ref == class. |
| 1325 | GenSelectConst32(ref_class_reg, class_reg, kCondEq, 1, 0, rl_result.reg, |
Andreas Gampe | 90969af | 2014-07-15 23:02:11 -0700 | [diff] [blame] | 1326 | kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1327 | } else { |
| 1328 | if (cu_->instruction_set == kThumb2) { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1329 | RegStorage r_tgt = LoadHelper(kQuickInstanceofNonTrivial); |
Dave Allison | 3da67a5 | 2014-04-02 17:03:45 -0700 | [diff] [blame] | 1330 | LIR* it = nullptr; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1331 | if (!type_known_abstract) { |
| 1332 | /* Uses conditional nullification */ |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1333 | OpRegReg(kOpCmp, ref_class_reg, class_reg); // Same? |
Dave Allison | 3da67a5 | 2014-04-02 17:03:45 -0700 | [diff] [blame] | 1334 | it = OpIT(kCondEq, "EE"); // if-convert the test |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1335 | LoadConstant(rl_result.reg, 1); // .eq case - load true |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1336 | } |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1337 | OpRegCopy(ref_reg, class_reg); // .ne case - arg0 <= class |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1338 | OpReg(kOpBlx, r_tgt); // .ne case: helper(class, ref->class) |
Dave Allison | 3da67a5 | 2014-04-02 17:03:45 -0700 | [diff] [blame] | 1339 | if (it != nullptr) { |
| 1340 | OpEndIT(it); |
| 1341 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1342 | FreeTemp(r_tgt); |
| 1343 | } else { |
| 1344 | if (!type_known_abstract) { |
| 1345 | /* Uses branchovers */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1346 | LoadConstant(rl_result.reg, 1); // assume true |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1347 | branchover = OpCmpBranch(kCondEq, TargetReg(kArg1, kRef), TargetReg(kArg2, kRef), NULL); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1348 | } |
Andreas Gampe | 90969af | 2014-07-15 23:02:11 -0700 | [diff] [blame] | 1349 | |
Serguei Katkov | 9ee4519 | 2014-07-17 14:39:03 +0700 | [diff] [blame] | 1350 | OpRegCopy(TargetReg(kArg0, kRef), class_reg); // .ne case - arg0 <= class |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1351 | CallRuntimeHelper(kQuickInstanceofNonTrivial, false); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1352 | } |
| 1353 | } |
| 1354 | // TODO: only clobber when type isn't final? |
Vladimir Marko | 31c2aac | 2013-12-09 16:31:19 +0000 | [diff] [blame] | 1355 | ClobberCallerSave(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1356 | /* branch targets here */ |
| 1357 | LIR* target = NewLIR0(kPseudoTargetLabel); |
| 1358 | StoreValue(rl_dest, rl_result); |
| 1359 | branch1->target = target; |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1360 | if (branchover != nullptr) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1361 | branchover->target = target; |
| 1362 | } |
| 1363 | } |
| 1364 | |
| 1365 | void Mir2Lir::GenInstanceof(uint32_t type_idx, RegLocation rl_dest, RegLocation rl_src) { |
| 1366 | bool type_known_final, type_known_abstract, use_declaring_class; |
| 1367 | bool needs_access_check = !cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, |
| 1368 | *cu_->dex_file, |
| 1369 | type_idx, |
| 1370 | &type_known_final, |
| 1371 | &type_known_abstract, |
| 1372 | &use_declaring_class); |
| 1373 | bool can_assume_type_is_in_dex_cache = !needs_access_check && |
| 1374 | cu_->compiler_driver->CanAssumeTypeIsPresentInDexCache(*cu_->dex_file, type_idx); |
| 1375 | |
| 1376 | if ((use_declaring_class || can_assume_type_is_in_dex_cache) && type_known_final) { |
| 1377 | GenInstanceofFinal(use_declaring_class, type_idx, rl_dest, rl_src); |
| 1378 | } else { |
| 1379 | GenInstanceofCallingHelper(needs_access_check, type_known_final, type_known_abstract, |
| 1380 | use_declaring_class, can_assume_type_is_in_dex_cache, |
| 1381 | type_idx, rl_dest, rl_src); |
| 1382 | } |
| 1383 | } |
| 1384 | |
Vladimir Marko | 22fe45d | 2015-03-18 11:33:58 +0000 | [diff] [blame] | 1385 | void Mir2Lir::GenCheckCast(int opt_flags, uint32_t insn_idx, uint32_t type_idx, |
| 1386 | RegLocation rl_src) { |
| 1387 | if ((opt_flags & MIR_IGNORE_CHECK_CAST) != 0) { |
| 1388 | // Compiler analysis proved that this check-cast would never cause an exception. |
| 1389 | return; |
| 1390 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1391 | bool type_known_final, type_known_abstract, use_declaring_class; |
| 1392 | bool needs_access_check = !cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, |
| 1393 | *cu_->dex_file, |
| 1394 | type_idx, |
| 1395 | &type_known_final, |
| 1396 | &type_known_abstract, |
| 1397 | &use_declaring_class); |
| 1398 | // Note: currently type_known_final is unused, as optimizing will only improve the performance |
| 1399 | // of the exception throw path. |
| 1400 | DexCompilationUnit* cu = mir_graph_->GetCurrentDexCompilationUnit(); |
Vladimir Marko | 2730db0 | 2014-01-27 11:15:17 +0000 | [diff] [blame] | 1401 | if (!needs_access_check && cu_->compiler_driver->IsSafeCast(cu, insn_idx)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1402 | // Verifier type analysis proved this check cast would never cause an exception. |
| 1403 | return; |
| 1404 | } |
| 1405 | FlushAllRegs(); |
| 1406 | // May generate a call - use explicit registers |
| 1407 | LockCallTemps(); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1408 | RegStorage class_reg = TargetReg(kArg2, kRef); // kArg2 will hold the Class* |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1409 | if (needs_access_check) { |
| 1410 | // Check we have access to type_idx and if not throw IllegalAccessError, |
| 1411 | // returns Class* in kRet0 |
| 1412 | // InitializeTypeAndVerifyAccess(idx, method) |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1413 | CallRuntimeHelperImmMethod(kQuickInitializeTypeAndVerifyAccess, type_idx, true); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1414 | OpRegCopy(class_reg, TargetReg(kRet0, kRef)); // Align usage with fast path |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1415 | } else if (use_declaring_class) { |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1416 | RegStorage method_reg = LoadCurrMethodWithHint(TargetReg(kArg1, kRef)); |
Andreas Gampe | 4b537a8 | 2014-06-30 22:24:53 -0700 | [diff] [blame] | 1417 | LoadRefDisp(method_reg, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), |
Andreas Gampe | 3c12c51 | 2014-06-24 18:46:29 +0000 | [diff] [blame] | 1418 | class_reg, kNotVolatile); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1419 | } else { |
| 1420 | // Load dex cache entry into class_reg (kArg2) |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1421 | RegStorage r_method = RegStorage::InvalidReg(); |
| 1422 | if (CanUseOpPcRelDexCacheArrayLoad()) { |
| 1423 | size_t offset = dex_cache_arrays_layout_.TypeOffset(type_idx); |
| 1424 | OpPcRelDexCacheArrayLoad(cu_->dex_file, offset, class_reg); |
| 1425 | } else { |
| 1426 | r_method = LoadCurrMethodWithHint(TargetReg(kArg1, kRef)); |
| 1427 | |
| 1428 | LoadRefDisp(r_method, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), |
| 1429 | class_reg, kNotVolatile); |
| 1430 | int32_t offset_of_type = ClassArray::OffsetOfElement(type_idx).Int32Value(); |
| 1431 | LoadRefDisp(class_reg, offset_of_type, class_reg, kNotVolatile); |
| 1432 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1433 | if (!cu_->compiler_driver->CanAssumeTypeIsPresentInDexCache(*cu_->dex_file, type_idx)) { |
| 1434 | // Need to test presence of type in dex cache at runtime |
Vladimir Marko | 20f8559 | 2015-03-19 10:07:02 +0000 | [diff] [blame^] | 1435 | GenIfNullUseHelperImmMethod(class_reg, kQuickInitializeType, type_idx, r_method); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1436 | } |
| 1437 | } |
| 1438 | // At this point, class_reg (kArg2) has class |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1439 | LoadValueDirectFixed(rl_src, TargetReg(kArg0, kRef)); // kArg0 <= ref |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1440 | |
| 1441 | // Slow path for the case where the classes are not equal. In this case we need |
| 1442 | // to call a helper function to do the check. |
| 1443 | class SlowPath : public LIRSlowPath { |
| 1444 | public: |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 1445 | SlowPath(Mir2Lir* m2l, LIR* fromfast, LIR* cont, bool load) |
| 1446 | : LIRSlowPath(m2l, fromfast, cont), load_(load) { |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1447 | } |
| 1448 | |
| 1449 | void Compile() { |
| 1450 | GenerateTargetLabel(); |
| 1451 | |
| 1452 | if (load_) { |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1453 | m2l_->LoadRefDisp(m2l_->TargetReg(kArg0, kRef), mirror::Object::ClassOffset().Int32Value(), |
| 1454 | m2l_->TargetReg(kArg1, kRef), kNotVolatile); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1455 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1456 | m2l_->CallRuntimeHelperRegReg(kQuickCheckCast, m2l_->TargetReg(kArg2, kRef), |
| 1457 | m2l_->TargetReg(kArg1, kRef), true); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1458 | m2l_->OpUnconditionalBranch(cont_); |
| 1459 | } |
| 1460 | |
| 1461 | private: |
Mingyao Yang | 3b004ba | 2014-04-29 15:55:37 -0700 | [diff] [blame] | 1462 | const bool load_; |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1463 | }; |
| 1464 | |
| 1465 | if (type_known_abstract) { |
| 1466 | // Easier case, run slow path if target is non-null (slow path will load from target) |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1467 | LIR* branch = OpCmpImmBranch(kCondNe, TargetReg(kArg0, kRef), 0, nullptr); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1468 | LIR* cont = NewLIR0(kPseudoTargetLabel); |
| 1469 | AddSlowPath(new (arena_) SlowPath(this, branch, cont, true)); |
| 1470 | } else { |
| 1471 | // Harder, more common case. We need to generate a forward branch over the load |
| 1472 | // if the target is null. If it's non-null we perform the load and branch to the |
| 1473 | // slow path if the classes are not equal. |
| 1474 | |
| 1475 | /* Null is OK - continue */ |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1476 | LIR* branch1 = OpCmpImmBranch(kCondEq, TargetReg(kArg0, kRef), 0, nullptr); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1477 | /* load object->klass_ */ |
| 1478 | DCHECK_EQ(mirror::Object::ClassOffset().Int32Value(), 0); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1479 | LoadRefDisp(TargetReg(kArg0, kRef), mirror::Object::ClassOffset().Int32Value(), |
| 1480 | TargetReg(kArg1, kRef), kNotVolatile); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1481 | |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1482 | LIR* branch2 = OpCmpBranch(kCondNe, TargetReg(kArg1, kRef), class_reg, nullptr); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1483 | LIR* cont = NewLIR0(kPseudoTargetLabel); |
| 1484 | |
| 1485 | // Add the slow path that will not perform load since this is already done. |
| 1486 | AddSlowPath(new (arena_) SlowPath(this, branch2, cont, false)); |
| 1487 | |
| 1488 | // Set the null check to branch to the continuation. |
| 1489 | branch1->target = cont; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1490 | } |
| 1491 | } |
| 1492 | |
| 1493 | void Mir2Lir::GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_dest, |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1494 | RegLocation rl_src1, RegLocation rl_src2) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1495 | RegLocation rl_result; |
| 1496 | if (cu_->instruction_set == kThumb2) { |
| 1497 | /* |
| 1498 | * NOTE: This is the one place in the code in which we might have |
| 1499 | * as many as six live temporary registers. There are 5 in the normal |
| 1500 | * set for Arm. Until we have spill capabilities, temporarily add |
| 1501 | * lr to the temp set. It is safe to do this locally, but note that |
| 1502 | * lr is used explicitly elsewhere in the code generator and cannot |
| 1503 | * normally be used as a general temp register. |
| 1504 | */ |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1505 | MarkTemp(TargetReg(kLr, kNotWide)); // Add lr to the temp pool |
| 1506 | FreeTemp(TargetReg(kLr, kNotWide)); // and make it available |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1507 | } |
| 1508 | rl_src1 = LoadValueWide(rl_src1, kCoreReg); |
| 1509 | rl_src2 = LoadValueWide(rl_src2, kCoreReg); |
| 1510 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 1511 | // The longs may overlap - use intermediate temp if so |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1512 | if ((rl_result.reg.GetLowReg() == rl_src1.reg.GetHighReg()) || (rl_result.reg.GetLowReg() == rl_src2.reg.GetHighReg())) { |
| 1513 | RegStorage t_reg = AllocTemp(); |
| 1514 | OpRegRegReg(first_op, t_reg, rl_src1.reg.GetLow(), rl_src2.reg.GetLow()); |
| 1515 | OpRegRegReg(second_op, rl_result.reg.GetHigh(), rl_src1.reg.GetHigh(), rl_src2.reg.GetHigh()); |
| 1516 | OpRegCopy(rl_result.reg.GetLow(), t_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1517 | FreeTemp(t_reg); |
| 1518 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1519 | OpRegRegReg(first_op, rl_result.reg.GetLow(), rl_src1.reg.GetLow(), rl_src2.reg.GetLow()); |
| 1520 | OpRegRegReg(second_op, rl_result.reg.GetHigh(), rl_src1.reg.GetHigh(), rl_src2.reg.GetHigh()); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1521 | } |
| 1522 | /* |
| 1523 | * NOTE: If rl_dest refers to a frame variable in a large frame, the |
| 1524 | * following StoreValueWide might need to allocate a temp register. |
| 1525 | * To further work around the lack of a spill capability, explicitly |
| 1526 | * free any temps from rl_src1 & rl_src2 that aren't still live in rl_result. |
| 1527 | * Remove when spill is functional. |
| 1528 | */ |
| 1529 | FreeRegLocTemps(rl_result, rl_src1); |
| 1530 | FreeRegLocTemps(rl_result, rl_src2); |
| 1531 | StoreValueWide(rl_dest, rl_result); |
| 1532 | if (cu_->instruction_set == kThumb2) { |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1533 | Clobber(TargetReg(kLr, kNotWide)); |
| 1534 | UnmarkTemp(TargetReg(kLr, kNotWide)); // Remove lr from the temp pool |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1535 | } |
| 1536 | } |
| 1537 | |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1538 | void Mir2Lir::GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest, |
| 1539 | RegLocation rl_src1, RegLocation rl_shift) { |
| 1540 | QuickEntrypointEnum target; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1541 | switch (opcode) { |
| 1542 | case Instruction::SHL_LONG: |
| 1543 | case Instruction::SHL_LONG_2ADDR: |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1544 | target = kQuickShlLong; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1545 | break; |
| 1546 | case Instruction::SHR_LONG: |
| 1547 | case Instruction::SHR_LONG_2ADDR: |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1548 | target = kQuickShrLong; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1549 | break; |
| 1550 | case Instruction::USHR_LONG: |
| 1551 | case Instruction::USHR_LONG_2ADDR: |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1552 | target = kQuickUshrLong; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1553 | break; |
| 1554 | default: |
| 1555 | LOG(FATAL) << "Unexpected case"; |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1556 | target = kQuickShlLong; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1557 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1558 | FlushAllRegs(); /* Send everything to home location */ |
| 1559 | CallRuntimeHelperRegLocationRegLocation(target, rl_src1, rl_shift, false); |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1560 | RegLocation rl_result = GetReturnWide(kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1561 | StoreValueWide(rl_dest, rl_result); |
| 1562 | } |
| 1563 | |
| 1564 | |
| 1565 | void Mir2Lir::GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest, |
Razvan A Lupusoru | 5c5676b | 2014-09-29 16:42:11 -0700 | [diff] [blame] | 1566 | RegLocation rl_src1, RegLocation rl_src2, int flags) { |
Dmitry Petrochenko | 6a58cb1 | 2014-04-02 17:27:59 +0700 | [diff] [blame] | 1567 | DCHECK(cu_->instruction_set != kX86 && cu_->instruction_set != kX86_64); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1568 | OpKind op = kOpBkpt; |
| 1569 | bool is_div_rem = false; |
| 1570 | bool check_zero = false; |
| 1571 | bool unary = false; |
| 1572 | RegLocation rl_result; |
| 1573 | bool shift_op = false; |
| 1574 | switch (opcode) { |
| 1575 | case Instruction::NEG_INT: |
| 1576 | op = kOpNeg; |
| 1577 | unary = true; |
| 1578 | break; |
| 1579 | case Instruction::NOT_INT: |
| 1580 | op = kOpMvn; |
| 1581 | unary = true; |
| 1582 | break; |
| 1583 | case Instruction::ADD_INT: |
| 1584 | case Instruction::ADD_INT_2ADDR: |
| 1585 | op = kOpAdd; |
| 1586 | break; |
| 1587 | case Instruction::SUB_INT: |
| 1588 | case Instruction::SUB_INT_2ADDR: |
| 1589 | op = kOpSub; |
| 1590 | break; |
| 1591 | case Instruction::MUL_INT: |
| 1592 | case Instruction::MUL_INT_2ADDR: |
| 1593 | op = kOpMul; |
| 1594 | break; |
| 1595 | case Instruction::DIV_INT: |
| 1596 | case Instruction::DIV_INT_2ADDR: |
| 1597 | check_zero = true; |
| 1598 | op = kOpDiv; |
| 1599 | is_div_rem = true; |
| 1600 | break; |
| 1601 | /* NOTE: returns in kArg1 */ |
| 1602 | case Instruction::REM_INT: |
| 1603 | case Instruction::REM_INT_2ADDR: |
| 1604 | check_zero = true; |
| 1605 | op = kOpRem; |
| 1606 | is_div_rem = true; |
| 1607 | break; |
| 1608 | case Instruction::AND_INT: |
| 1609 | case Instruction::AND_INT_2ADDR: |
| 1610 | op = kOpAnd; |
| 1611 | break; |
| 1612 | case Instruction::OR_INT: |
| 1613 | case Instruction::OR_INT_2ADDR: |
| 1614 | op = kOpOr; |
| 1615 | break; |
| 1616 | case Instruction::XOR_INT: |
| 1617 | case Instruction::XOR_INT_2ADDR: |
| 1618 | op = kOpXor; |
| 1619 | break; |
| 1620 | case Instruction::SHL_INT: |
| 1621 | case Instruction::SHL_INT_2ADDR: |
| 1622 | shift_op = true; |
| 1623 | op = kOpLsl; |
| 1624 | break; |
| 1625 | case Instruction::SHR_INT: |
| 1626 | case Instruction::SHR_INT_2ADDR: |
| 1627 | shift_op = true; |
| 1628 | op = kOpAsr; |
| 1629 | break; |
| 1630 | case Instruction::USHR_INT: |
| 1631 | case Instruction::USHR_INT_2ADDR: |
| 1632 | shift_op = true; |
| 1633 | op = kOpLsr; |
| 1634 | break; |
| 1635 | default: |
| 1636 | LOG(FATAL) << "Invalid word arith op: " << opcode; |
| 1637 | } |
| 1638 | if (!is_div_rem) { |
| 1639 | if (unary) { |
| 1640 | rl_src1 = LoadValue(rl_src1, kCoreReg); |
| 1641 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1642 | OpRegReg(op, rl_result.reg, rl_src1.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1643 | } else { |
Serban Constantinescu | ed65c5e | 2014-05-22 15:10:18 +0100 | [diff] [blame] | 1644 | if ((shift_op) && (cu_->instruction_set != kArm64)) { |
Mark Mendell | feb2b4e | 2014-01-28 12:59:49 -0800 | [diff] [blame] | 1645 | rl_src2 = LoadValue(rl_src2, kCoreReg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1646 | RegStorage t_reg = AllocTemp(); |
| 1647 | OpRegRegImm(kOpAnd, t_reg, rl_src2.reg, 31); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1648 | rl_src1 = LoadValue(rl_src1, kCoreReg); |
| 1649 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1650 | OpRegRegReg(op, rl_result.reg, rl_src1.reg, t_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1651 | FreeTemp(t_reg); |
| 1652 | } else { |
| 1653 | rl_src1 = LoadValue(rl_src1, kCoreReg); |
| 1654 | rl_src2 = LoadValue(rl_src2, kCoreReg); |
| 1655 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1656 | OpRegRegReg(op, rl_result.reg, rl_src1.reg, rl_src2.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1657 | } |
| 1658 | } |
| 1659 | StoreValue(rl_dest, rl_result); |
| 1660 | } else { |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1661 | bool done = false; // Set to true if we happen to find a way to use a real instruction. |
Maja Gagic | 6ea651f | 2015-02-24 16:55:04 +0100 | [diff] [blame] | 1662 | if (cu_->instruction_set == kMips || cu_->instruction_set == kMips64 || |
| 1663 | cu_->instruction_set == kArm64) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1664 | rl_src1 = LoadValue(rl_src1, kCoreReg); |
| 1665 | rl_src2 = LoadValue(rl_src2, kCoreReg); |
Razvan A Lupusoru | 5c5676b | 2014-09-29 16:42:11 -0700 | [diff] [blame] | 1666 | if (check_zero && (flags & MIR_IGNORE_DIV_ZERO_CHECK) == 0) { |
Mingyao Yang | d15f4e2 | 2014-04-17 18:46:24 -0700 | [diff] [blame] | 1667 | GenDivZeroCheck(rl_src2.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1668 | } |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1669 | rl_result = GenDivRem(rl_dest, rl_src1.reg, rl_src2.reg, op == kOpDiv); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1670 | done = true; |
| 1671 | } else if (cu_->instruction_set == kThumb2) { |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 1672 | if (cu_->compiler_driver->GetInstructionSetFeatures()->AsArmInstructionSetFeatures()-> |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 1673 | HasDivideInstruction()) { |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1674 | // Use ARM SDIV instruction for division. For remainder we also need to |
| 1675 | // calculate using a MUL and subtract. |
| 1676 | rl_src1 = LoadValue(rl_src1, kCoreReg); |
| 1677 | rl_src2 = LoadValue(rl_src2, kCoreReg); |
Razvan A Lupusoru | 5c5676b | 2014-09-29 16:42:11 -0700 | [diff] [blame] | 1678 | if (check_zero && (flags & MIR_IGNORE_DIV_ZERO_CHECK) == 0) { |
Mingyao Yang | d15f4e2 | 2014-04-17 18:46:24 -0700 | [diff] [blame] | 1679 | GenDivZeroCheck(rl_src2.reg); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1680 | } |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1681 | rl_result = GenDivRem(rl_dest, rl_src1.reg, rl_src2.reg, op == kOpDiv); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1682 | done = true; |
| 1683 | } |
| 1684 | } |
| 1685 | |
| 1686 | // If we haven't already generated the code use the callout function. |
| 1687 | if (!done) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1688 | FlushAllRegs(); /* Send everything to home location */ |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1689 | LoadValueDirectFixed(rl_src2, TargetReg(kArg1, kNotWide)); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1690 | RegStorage r_tgt = CallHelperSetup(kQuickIdivmod); |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1691 | LoadValueDirectFixed(rl_src1, TargetReg(kArg0, kNotWide)); |
Razvan A Lupusoru | 5c5676b | 2014-09-29 16:42:11 -0700 | [diff] [blame] | 1692 | if (check_zero && (flags & MIR_IGNORE_DIV_ZERO_CHECK) == 0) { |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1693 | GenDivZeroCheck(TargetReg(kArg1, kNotWide)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1694 | } |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1695 | // NOTE: callout here is not a safepoint. |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1696 | CallHelper(r_tgt, kQuickIdivmod, false /* not a safepoint */); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1697 | if (op == kOpDiv) |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1698 | rl_result = GetReturn(kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1699 | else |
| 1700 | rl_result = GetReturnAlt(); |
| 1701 | } |
| 1702 | StoreValue(rl_dest, rl_result); |
| 1703 | } |
| 1704 | } |
| 1705 | |
| 1706 | /* |
| 1707 | * The following are the first-level codegen routines that analyze the format |
| 1708 | * of each bytecode then either dispatch special purpose codegen routines |
| 1709 | * or produce corresponding Thumb instructions directly. |
| 1710 | */ |
| 1711 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1712 | // Returns true if no more than two bits are set in 'x'. |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1713 | static bool IsPopCountLE2(unsigned int x) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1714 | x &= x - 1; |
| 1715 | return (x & (x - 1)) == 0; |
| 1716 | } |
| 1717 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1718 | // Returns true if it added instructions to 'cu' to divide 'rl_src' by 'lit' |
| 1719 | // and store the result in 'rl_dest'. |
Andreas Gampe | d500b53 | 2015-01-16 22:09:55 -0800 | [diff] [blame] | 1720 | bool Mir2Lir::HandleEasyDivRem(Instruction::Code dalvik_opcode ATTRIBUTE_UNUSED, bool is_div, |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1721 | RegLocation rl_src, RegLocation rl_dest, int lit) { |
Andreas Gampe | d500b53 | 2015-01-16 22:09:55 -0800 | [diff] [blame] | 1722 | if ((lit < 2) || (!IsPowerOfTwo(lit))) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1723 | return false; |
| 1724 | } |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 1725 | int k = CTZ(lit); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1726 | if (k >= 30) { |
| 1727 | // Avoid special cases. |
| 1728 | return false; |
| 1729 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1730 | rl_src = LoadValue(rl_src, kCoreReg); |
| 1731 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
buzbee | 11b63d1 | 2013-08-27 07:34:17 -0700 | [diff] [blame] | 1732 | if (is_div) { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1733 | RegStorage t_reg = AllocTemp(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1734 | if (lit == 2) { |
| 1735 | // Division by 2 is by far the most common division by constant. |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1736 | OpRegRegImm(kOpLsr, t_reg, rl_src.reg, 32 - k); |
| 1737 | OpRegRegReg(kOpAdd, t_reg, t_reg, rl_src.reg); |
| 1738 | OpRegRegImm(kOpAsr, rl_result.reg, t_reg, k); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1739 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1740 | OpRegRegImm(kOpAsr, t_reg, rl_src.reg, 31); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1741 | OpRegRegImm(kOpLsr, t_reg, t_reg, 32 - k); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1742 | OpRegRegReg(kOpAdd, t_reg, t_reg, rl_src.reg); |
| 1743 | OpRegRegImm(kOpAsr, rl_result.reg, t_reg, k); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1744 | } |
| 1745 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1746 | RegStorage t_reg1 = AllocTemp(); |
| 1747 | RegStorage t_reg2 = AllocTemp(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1748 | if (lit == 2) { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1749 | OpRegRegImm(kOpLsr, t_reg1, rl_src.reg, 32 - k); |
| 1750 | OpRegRegReg(kOpAdd, t_reg2, t_reg1, rl_src.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1751 | OpRegRegImm(kOpAnd, t_reg2, t_reg2, lit -1); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1752 | OpRegRegReg(kOpSub, rl_result.reg, t_reg2, t_reg1); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1753 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1754 | OpRegRegImm(kOpAsr, t_reg1, rl_src.reg, 31); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1755 | OpRegRegImm(kOpLsr, t_reg1, t_reg1, 32 - k); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1756 | OpRegRegReg(kOpAdd, t_reg2, t_reg1, rl_src.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1757 | OpRegRegImm(kOpAnd, t_reg2, t_reg2, lit - 1); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1758 | OpRegRegReg(kOpSub, rl_result.reg, t_reg2, t_reg1); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1759 | } |
| 1760 | } |
| 1761 | StoreValue(rl_dest, rl_result); |
| 1762 | return true; |
| 1763 | } |
| 1764 | |
| 1765 | // Returns true if it added instructions to 'cu' to multiply 'rl_src' by 'lit' |
| 1766 | // and store the result in 'rl_dest'. |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1767 | bool Mir2Lir::HandleEasyMultiply(RegLocation rl_src, RegLocation rl_dest, int lit) { |
Ian Rogers | e2143c0 | 2014-03-28 08:47:16 -0700 | [diff] [blame] | 1768 | if (lit < 0) { |
| 1769 | return false; |
| 1770 | } |
| 1771 | if (lit == 0) { |
| 1772 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 1773 | LoadConstant(rl_result.reg, 0); |
| 1774 | StoreValue(rl_dest, rl_result); |
| 1775 | return true; |
| 1776 | } |
| 1777 | if (lit == 1) { |
| 1778 | rl_src = LoadValue(rl_src, kCoreReg); |
| 1779 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 1780 | OpRegCopy(rl_result.reg, rl_src.reg); |
| 1781 | StoreValue(rl_dest, rl_result); |
| 1782 | return true; |
| 1783 | } |
Zheng Xu | f9719f9 | 2014-04-02 13:31:31 +0100 | [diff] [blame] | 1784 | // There is RegRegRegShift on Arm, so check for more special cases |
| 1785 | if (cu_->instruction_set == kThumb2) { |
Ian Rogers | e2143c0 | 2014-03-28 08:47:16 -0700 | [diff] [blame] | 1786 | return EasyMultiply(rl_src, rl_dest, lit); |
| 1787 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1788 | // Can we simplify this multiplication? |
| 1789 | bool power_of_two = false; |
| 1790 | bool pop_count_le2 = false; |
| 1791 | bool power_of_two_minus_one = false; |
Ian Rogers | e2143c0 | 2014-03-28 08:47:16 -0700 | [diff] [blame] | 1792 | if (IsPowerOfTwo(lit)) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1793 | power_of_two = true; |
| 1794 | } else if (IsPopCountLE2(lit)) { |
| 1795 | pop_count_le2 = true; |
| 1796 | } else if (IsPowerOfTwo(lit + 1)) { |
| 1797 | power_of_two_minus_one = true; |
| 1798 | } else { |
| 1799 | return false; |
| 1800 | } |
| 1801 | rl_src = LoadValue(rl_src, kCoreReg); |
| 1802 | RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 1803 | if (power_of_two) { |
| 1804 | // Shift. |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 1805 | OpRegRegImm(kOpLsl, rl_result.reg, rl_src.reg, CTZ(lit)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1806 | } else if (pop_count_le2) { |
| 1807 | // Shift and add and shift. |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 1808 | int first_bit = CTZ(lit); |
| 1809 | int second_bit = CTZ(lit ^ (1 << first_bit)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1810 | GenMultiplyByTwoBitMultiplier(rl_src, rl_result, lit, first_bit, second_bit); |
| 1811 | } else { |
| 1812 | // Reverse subtract: (src << (shift + 1)) - src. |
| 1813 | DCHECK(power_of_two_minus_one); |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 1814 | // TUNING: rsb dst, src, src lsl#CTZ(lit + 1) |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1815 | RegStorage t_reg = AllocTemp(); |
Andreas Gampe | 7e49992 | 2015-01-06 08:28:12 -0800 | [diff] [blame] | 1816 | OpRegRegImm(kOpLsl, t_reg, rl_src.reg, CTZ(lit + 1)); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1817 | OpRegRegReg(kOpSub, rl_result.reg, t_reg, rl_src.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1818 | } |
| 1819 | StoreValue(rl_dest, rl_result); |
| 1820 | return true; |
| 1821 | } |
| 1822 | |
Ningsheng Jian | 675e09b | 2014-10-23 13:48:36 +0800 | [diff] [blame] | 1823 | // Returns true if it generates instructions. |
| 1824 | bool Mir2Lir::HandleEasyFloatingPointDiv(RegLocation rl_dest, RegLocation rl_src1, |
| 1825 | RegLocation rl_src2) { |
| 1826 | if (!rl_src2.is_const || |
| 1827 | ((cu_->instruction_set != kThumb2) && (cu_->instruction_set != kArm64))) { |
| 1828 | return false; |
| 1829 | } |
| 1830 | |
| 1831 | if (!rl_src2.wide) { |
| 1832 | int32_t divisor = mir_graph_->ConstantValue(rl_src2); |
| 1833 | if (CanDivideByReciprocalMultiplyFloat(divisor)) { |
| 1834 | // Generate multiply by reciprocal instead of div. |
Roland Levillain | da4d79b | 2015-03-24 14:36:11 +0000 | [diff] [blame] | 1835 | float recip = 1.0f/bit_cast<float, int32_t>(divisor); |
| 1836 | GenMultiplyByConstantFloat(rl_dest, rl_src1, bit_cast<int32_t, float>(recip)); |
Ningsheng Jian | 675e09b | 2014-10-23 13:48:36 +0800 | [diff] [blame] | 1837 | return true; |
| 1838 | } |
| 1839 | } else { |
| 1840 | int64_t divisor = mir_graph_->ConstantValueWide(rl_src2); |
| 1841 | if (CanDivideByReciprocalMultiplyDouble(divisor)) { |
| 1842 | // Generate multiply by reciprocal instead of div. |
| 1843 | double recip = 1.0/bit_cast<double, int64_t>(divisor); |
Roland Levillain | da4d79b | 2015-03-24 14:36:11 +0000 | [diff] [blame] | 1844 | GenMultiplyByConstantDouble(rl_dest, rl_src1, bit_cast<int64_t, double>(recip)); |
Ningsheng Jian | 675e09b | 2014-10-23 13:48:36 +0800 | [diff] [blame] | 1845 | return true; |
| 1846 | } |
| 1847 | } |
| 1848 | return false; |
| 1849 | } |
| 1850 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1851 | void Mir2Lir::GenArithOpIntLit(Instruction::Code opcode, RegLocation rl_dest, RegLocation rl_src, |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 1852 | int lit) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1853 | RegLocation rl_result; |
| 1854 | OpKind op = static_cast<OpKind>(0); /* Make gcc happy */ |
| 1855 | int shift_op = false; |
| 1856 | bool is_div = false; |
| 1857 | |
| 1858 | switch (opcode) { |
| 1859 | case Instruction::RSUB_INT_LIT8: |
| 1860 | case Instruction::RSUB_INT: { |
| 1861 | rl_src = LoadValue(rl_src, kCoreReg); |
| 1862 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
| 1863 | if (cu_->instruction_set == kThumb2) { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1864 | OpRegRegImm(kOpRsub, rl_result.reg, rl_src.reg, lit); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1865 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1866 | OpRegReg(kOpNeg, rl_result.reg, rl_src.reg); |
| 1867 | OpRegImm(kOpAdd, rl_result.reg, lit); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1868 | } |
| 1869 | StoreValue(rl_dest, rl_result); |
| 1870 | return; |
| 1871 | } |
| 1872 | |
| 1873 | case Instruction::SUB_INT: |
| 1874 | case Instruction::SUB_INT_2ADDR: |
| 1875 | lit = -lit; |
Ian Rogers | fc787ec | 2014-10-09 21:56:44 -0700 | [diff] [blame] | 1876 | FALLTHROUGH_INTENDED; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1877 | case Instruction::ADD_INT: |
| 1878 | case Instruction::ADD_INT_2ADDR: |
| 1879 | case Instruction::ADD_INT_LIT8: |
| 1880 | case Instruction::ADD_INT_LIT16: |
| 1881 | op = kOpAdd; |
| 1882 | break; |
| 1883 | case Instruction::MUL_INT: |
| 1884 | case Instruction::MUL_INT_2ADDR: |
| 1885 | case Instruction::MUL_INT_LIT8: |
| 1886 | case Instruction::MUL_INT_LIT16: { |
| 1887 | if (HandleEasyMultiply(rl_src, rl_dest, lit)) { |
| 1888 | return; |
| 1889 | } |
| 1890 | op = kOpMul; |
| 1891 | break; |
| 1892 | } |
| 1893 | case Instruction::AND_INT: |
| 1894 | case Instruction::AND_INT_2ADDR: |
| 1895 | case Instruction::AND_INT_LIT8: |
| 1896 | case Instruction::AND_INT_LIT16: |
| 1897 | op = kOpAnd; |
| 1898 | break; |
| 1899 | case Instruction::OR_INT: |
| 1900 | case Instruction::OR_INT_2ADDR: |
| 1901 | case Instruction::OR_INT_LIT8: |
| 1902 | case Instruction::OR_INT_LIT16: |
| 1903 | op = kOpOr; |
| 1904 | break; |
| 1905 | case Instruction::XOR_INT: |
| 1906 | case Instruction::XOR_INT_2ADDR: |
| 1907 | case Instruction::XOR_INT_LIT8: |
| 1908 | case Instruction::XOR_INT_LIT16: |
| 1909 | op = kOpXor; |
| 1910 | break; |
| 1911 | case Instruction::SHL_INT_LIT8: |
| 1912 | case Instruction::SHL_INT: |
| 1913 | case Instruction::SHL_INT_2ADDR: |
| 1914 | lit &= 31; |
| 1915 | shift_op = true; |
| 1916 | op = kOpLsl; |
| 1917 | break; |
| 1918 | case Instruction::SHR_INT_LIT8: |
| 1919 | case Instruction::SHR_INT: |
| 1920 | case Instruction::SHR_INT_2ADDR: |
| 1921 | lit &= 31; |
| 1922 | shift_op = true; |
| 1923 | op = kOpAsr; |
| 1924 | break; |
| 1925 | case Instruction::USHR_INT_LIT8: |
| 1926 | case Instruction::USHR_INT: |
| 1927 | case Instruction::USHR_INT_2ADDR: |
| 1928 | lit &= 31; |
| 1929 | shift_op = true; |
| 1930 | op = kOpLsr; |
| 1931 | break; |
| 1932 | |
| 1933 | case Instruction::DIV_INT: |
| 1934 | case Instruction::DIV_INT_2ADDR: |
| 1935 | case Instruction::DIV_INT_LIT8: |
| 1936 | case Instruction::DIV_INT_LIT16: |
| 1937 | case Instruction::REM_INT: |
| 1938 | case Instruction::REM_INT_2ADDR: |
| 1939 | case Instruction::REM_INT_LIT8: |
| 1940 | case Instruction::REM_INT_LIT16: { |
| 1941 | if (lit == 0) { |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 1942 | GenDivZeroException(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1943 | return; |
| 1944 | } |
buzbee | 11b63d1 | 2013-08-27 07:34:17 -0700 | [diff] [blame] | 1945 | if ((opcode == Instruction::DIV_INT) || |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1946 | (opcode == Instruction::DIV_INT_2ADDR) || |
buzbee | 11b63d1 | 2013-08-27 07:34:17 -0700 | [diff] [blame] | 1947 | (opcode == Instruction::DIV_INT_LIT8) || |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1948 | (opcode == Instruction::DIV_INT_LIT16)) { |
| 1949 | is_div = true; |
| 1950 | } else { |
| 1951 | is_div = false; |
| 1952 | } |
buzbee | 11b63d1 | 2013-08-27 07:34:17 -0700 | [diff] [blame] | 1953 | if (HandleEasyDivRem(opcode, is_div, rl_src, rl_dest, lit)) { |
| 1954 | return; |
| 1955 | } |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1956 | |
| 1957 | bool done = false; |
Maja Gagic | 6ea651f | 2015-02-24 16:55:04 +0100 | [diff] [blame] | 1958 | if (cu_->instruction_set == kMips || cu_->instruction_set == kMips64 || |
| 1959 | cu_->instruction_set == kArm64) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1960 | rl_src = LoadValue(rl_src, kCoreReg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1961 | rl_result = GenDivRemLit(rl_dest, rl_src.reg, lit, is_div); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1962 | done = true; |
Dmitry Petrochenko | 6a58cb1 | 2014-04-02 17:27:59 +0700 | [diff] [blame] | 1963 | } else if (cu_->instruction_set == kX86 || cu_->instruction_set == kX86_64) { |
Mark Mendell | 2bf31e6 | 2014-01-23 12:13:40 -0800 | [diff] [blame] | 1964 | rl_result = GenDivRemLit(rl_dest, rl_src, lit, is_div); |
| 1965 | done = true; |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1966 | } else if (cu_->instruction_set == kThumb2) { |
Andreas Gampe | 0b9203e | 2015-01-22 20:39:27 -0800 | [diff] [blame] | 1967 | if (cu_->compiler_driver->GetInstructionSetFeatures()->AsArmInstructionSetFeatures()-> |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 1968 | HasDivideInstruction()) { |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1969 | // Use ARM SDIV instruction for division. For remainder we also need to |
| 1970 | // calculate using a MUL and subtract. |
| 1971 | rl_src = LoadValue(rl_src, kCoreReg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1972 | rl_result = GenDivRemLit(rl_dest, rl_src.reg, lit, is_div); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1973 | done = true; |
| 1974 | } |
| 1975 | } |
| 1976 | |
| 1977 | if (!done) { |
| 1978 | FlushAllRegs(); /* Everything to home location. */ |
Andreas Gampe | ccc6026 | 2014-07-04 18:02:38 -0700 | [diff] [blame] | 1979 | LoadValueDirectFixed(rl_src, TargetReg(kArg0, kNotWide)); |
| 1980 | Clobber(TargetReg(kArg0, kNotWide)); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 1981 | CallRuntimeHelperRegImm(kQuickIdivmod, TargetReg(kArg0, kNotWide), lit, false); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1982 | if (is_div) |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 1983 | rl_result = GetReturn(kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1984 | else |
| 1985 | rl_result = GetReturnAlt(); |
| 1986 | } |
| 1987 | StoreValue(rl_dest, rl_result); |
| 1988 | return; |
| 1989 | } |
| 1990 | default: |
| 1991 | LOG(FATAL) << "Unexpected opcode " << opcode; |
| 1992 | } |
| 1993 | rl_src = LoadValue(rl_src, kCoreReg); |
| 1994 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 1995 | // Avoid shifts by literal 0 - no support in Thumb. Change to copy. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1996 | if (shift_op && (lit == 0)) { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1997 | OpRegCopy(rl_result.reg, rl_src.reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1998 | } else { |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1999 | OpRegRegImm(op, rl_result.reg, rl_src.reg, lit); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2000 | } |
| 2001 | StoreValue(rl_dest, rl_result); |
| 2002 | } |
| 2003 | |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2004 | void Mir2Lir::GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest, |
Razvan A Lupusoru | 5c5676b | 2014-09-29 16:42:11 -0700 | [diff] [blame] | 2005 | RegLocation rl_src1, RegLocation rl_src2, int flags) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2006 | RegLocation rl_result; |
| 2007 | OpKind first_op = kOpBkpt; |
| 2008 | OpKind second_op = kOpBkpt; |
| 2009 | bool call_out = false; |
| 2010 | bool check_zero = false; |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2011 | int ret_reg = TargetReg(kRet0, kNotWide).GetReg(); |
| 2012 | QuickEntrypointEnum target; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2013 | |
| 2014 | switch (opcode) { |
| 2015 | case Instruction::NOT_LONG: |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2016 | rl_src2 = LoadValueWide(rl_src2, kCoreReg); |
| 2017 | rl_result = EvalLoc(rl_dest, kCoreReg, true); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2018 | // Check for destructive overlap |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 2019 | if (rl_result.reg.GetLowReg() == rl_src2.reg.GetHighReg()) { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2020 | RegStorage t_reg = AllocTemp(); |
| 2021 | OpRegCopy(t_reg, rl_src2.reg.GetHigh()); |
| 2022 | OpRegReg(kOpMvn, rl_result.reg.GetLow(), rl_src2.reg.GetLow()); |
| 2023 | OpRegReg(kOpMvn, rl_result.reg.GetHigh(), t_reg); |
| 2024 | FreeTemp(t_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2025 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2026 | OpRegReg(kOpMvn, rl_result.reg.GetLow(), rl_src2.reg.GetLow()); |
| 2027 | OpRegReg(kOpMvn, rl_result.reg.GetHigh(), rl_src2.reg.GetHigh()); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2028 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2029 | StoreValueWide(rl_dest, rl_result); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2030 | return; |
| 2031 | case Instruction::ADD_LONG: |
| 2032 | case Instruction::ADD_LONG_2ADDR: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2033 | first_op = kOpAdd; |
| 2034 | second_op = kOpAdc; |
| 2035 | break; |
| 2036 | case Instruction::SUB_LONG: |
| 2037 | case Instruction::SUB_LONG_2ADDR: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2038 | first_op = kOpSub; |
| 2039 | second_op = kOpSbc; |
| 2040 | break; |
| 2041 | case Instruction::MUL_LONG: |
| 2042 | case Instruction::MUL_LONG_2ADDR: |
Andreas Gampe | c76c614 | 2014-08-04 16:30:03 -0700 | [diff] [blame] | 2043 | call_out = true; |
| 2044 | ret_reg = TargetReg(kRet0, kNotWide).GetReg(); |
| 2045 | target = kQuickLmul; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2046 | break; |
| 2047 | case Instruction::DIV_LONG: |
| 2048 | case Instruction::DIV_LONG_2ADDR: |
| 2049 | call_out = true; |
| 2050 | check_zero = true; |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2051 | ret_reg = TargetReg(kRet0, kNotWide).GetReg(); |
| 2052 | target = kQuickLdiv; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2053 | break; |
| 2054 | case Instruction::REM_LONG: |
| 2055 | case Instruction::REM_LONG_2ADDR: |
| 2056 | call_out = true; |
| 2057 | check_zero = true; |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2058 | target = kQuickLmod; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2059 | /* NOTE - for Arm, result is in kArg2/kArg3 instead of kRet0/kRet1 */ |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2060 | ret_reg = (cu_->instruction_set == kThumb2) ? TargetReg(kArg2, kNotWide).GetReg() : |
| 2061 | TargetReg(kRet0, kNotWide).GetReg(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2062 | break; |
| 2063 | case Instruction::AND_LONG_2ADDR: |
| 2064 | case Instruction::AND_LONG: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2065 | first_op = kOpAnd; |
| 2066 | second_op = kOpAnd; |
| 2067 | break; |
| 2068 | case Instruction::OR_LONG: |
| 2069 | case Instruction::OR_LONG_2ADDR: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2070 | first_op = kOpOr; |
| 2071 | second_op = kOpOr; |
| 2072 | break; |
| 2073 | case Instruction::XOR_LONG: |
| 2074 | case Instruction::XOR_LONG_2ADDR: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2075 | first_op = kOpXor; |
| 2076 | second_op = kOpXor; |
| 2077 | break; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2078 | default: |
| 2079 | LOG(FATAL) << "Invalid long arith op"; |
| 2080 | } |
| 2081 | if (!call_out) { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2082 | GenLong3Addr(first_op, second_op, rl_dest, rl_src1, rl_src2); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2083 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2084 | FlushAllRegs(); /* Send everything to home location */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2085 | if (check_zero) { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2086 | RegStorage r_tmp1 = TargetReg(kArg0, kWide); |
| 2087 | RegStorage r_tmp2 = TargetReg(kArg2, kWide); |
| 2088 | LoadValueDirectWideFixed(rl_src2, r_tmp2); |
| 2089 | RegStorage r_tgt = CallHelperSetup(target); |
Razvan A Lupusoru | 5c5676b | 2014-09-29 16:42:11 -0700 | [diff] [blame] | 2090 | if ((flags & MIR_IGNORE_DIV_ZERO_CHECK) == 0) { |
| 2091 | GenDivZeroCheckWide(r_tmp2); |
| 2092 | } |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2093 | LoadValueDirectWideFixed(rl_src1, r_tmp1); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2094 | // NOTE: callout here is not a safepoint |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2095 | CallHelper(r_tgt, target, false /* not safepoint */); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2096 | } else { |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2097 | CallRuntimeHelperRegLocationRegLocation(target, rl_src1, rl_src2, false); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2098 | } |
| 2099 | // Adjust return regs in to handle case of rem returning kArg2/kArg3 |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2100 | if (ret_reg == TargetReg(kRet0, kNotWide).GetReg()) |
| 2101 | rl_result = GetReturnWide(kCoreReg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2102 | else |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2103 | rl_result = GetReturnWideAlt(); |
| 2104 | StoreValueWide(rl_dest, rl_result); |
Andreas Gampe | 2f244e9 | 2014-05-08 03:35:25 -0700 | [diff] [blame] | 2105 | } |
| 2106 | } |
| 2107 | |
Mark Mendell | e87f9b5 | 2014-04-30 14:13:18 -0400 | [diff] [blame] | 2108 | void Mir2Lir::GenConst(RegLocation rl_dest, int value) { |
| 2109 | RegLocation rl_result = EvalLoc(rl_dest, kAnyReg, true); |
| 2110 | LoadConstantNoClobber(rl_result.reg, value); |
| 2111 | StoreValue(rl_dest, rl_result); |
Mark Mendell | e87f9b5 | 2014-04-30 14:13:18 -0400 | [diff] [blame] | 2112 | } |
| 2113 | |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2114 | void Mir2Lir::GenConversionCall(QuickEntrypointEnum trampoline, RegLocation rl_dest, |
| 2115 | RegLocation rl_src) { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2116 | /* |
| 2117 | * Don't optimize the register usage since it calls out to support |
| 2118 | * functions |
| 2119 | */ |
Andreas Gampe | 2f244e9 | 2014-05-08 03:35:25 -0700 | [diff] [blame] | 2120 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2121 | FlushAllRegs(); /* Send everything to home location */ |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2122 | CallRuntimeHelperRegLocation(trampoline, rl_src, false); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2123 | if (rl_dest.wide) { |
| 2124 | RegLocation rl_result; |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 2125 | rl_result = GetReturnWide(LocToRegClass(rl_dest)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2126 | StoreValueWide(rl_dest, rl_result); |
| 2127 | } else { |
| 2128 | RegLocation rl_result; |
buzbee | a0cd2d7 | 2014-06-01 09:33:49 -0700 | [diff] [blame] | 2129 | rl_result = GetReturn(LocToRegClass(rl_dest)); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2130 | StoreValue(rl_dest, rl_result); |
| 2131 | } |
| 2132 | } |
| 2133 | |
Vladimir Marko | 6ce3eba | 2015-02-16 13:05:59 +0000 | [diff] [blame] | 2134 | class Mir2Lir::SuspendCheckSlowPath : public Mir2Lir::LIRSlowPath { |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 2135 | public: |
| 2136 | SuspendCheckSlowPath(Mir2Lir* m2l, LIR* branch, LIR* cont) |
Vladimir Marko | 0b40ecf | 2015-03-20 12:08:03 +0000 | [diff] [blame] | 2137 | : LIRSlowPath(m2l, branch, cont) { |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 2138 | } |
| 2139 | |
| 2140 | void Compile() OVERRIDE { |
| 2141 | m2l_->ResetRegPool(); |
| 2142 | m2l_->ResetDefTracking(); |
| 2143 | GenerateTargetLabel(kPseudoSuspendTarget); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2144 | m2l_->CallRuntimeHelper(kQuickTestSuspend, true); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 2145 | if (cont_ != nullptr) { |
| 2146 | m2l_->OpUnconditionalBranch(cont_); |
| 2147 | } |
| 2148 | } |
| 2149 | }; |
| 2150 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2151 | /* Check if we need to check for pending suspend request */ |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 2152 | void Mir2Lir::GenSuspendTest(int opt_flags) { |
Vladimir Marko | 8b858e1 | 2014-11-27 14:52:37 +0000 | [diff] [blame] | 2153 | if (NO_SUSPEND || (opt_flags & MIR_IGNORE_SUSPEND_CHECK) != 0) { |
| 2154 | return; |
| 2155 | } |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 2156 | if (!cu_->compiler_driver->GetCompilerOptions().GetImplicitSuspendChecks()) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2157 | FlushAllRegs(); |
| 2158 | LIR* branch = OpTestSuspend(NULL); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 2159 | LIR* cont = NewLIR0(kPseudoTargetLabel); |
| 2160 | AddSlowPath(new (arena_) SuspendCheckSlowPath(this, branch, cont)); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2161 | } else { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2162 | FlushAllRegs(); // TODO: needed? |
| 2163 | LIR* inst = CheckSuspendUsingLoad(); |
| 2164 | MarkSafepointPC(inst); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2165 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2166 | } |
| 2167 | |
| 2168 | /* Check if we need to check for pending suspend request */ |
Brian Carlstrom | 2ce745c | 2013-07-17 17:44:30 -0700 | [diff] [blame] | 2169 | void Mir2Lir::GenSuspendTestAndBranch(int opt_flags, LIR* target) { |
Vladimir Marko | 8b858e1 | 2014-11-27 14:52:37 +0000 | [diff] [blame] | 2170 | if (NO_SUSPEND || (opt_flags & MIR_IGNORE_SUSPEND_CHECK) != 0) { |
| 2171 | OpUnconditionalBranch(target); |
| 2172 | return; |
| 2173 | } |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 2174 | if (!cu_->compiler_driver->GetCompilerOptions().GetImplicitSuspendChecks()) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2175 | OpTestSuspend(target); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2176 | FlushAllRegs(); |
Mingyao Yang | 6ffcfa0 | 2014-04-25 11:06:00 -0700 | [diff] [blame] | 2177 | LIR* branch = OpUnconditionalBranch(nullptr); |
| 2178 | AddSlowPath(new (arena_) SuspendCheckSlowPath(this, branch, target)); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2179 | } else { |
| 2180 | // For the implicit suspend check, just perform the trigger |
| 2181 | // load and branch to the target. |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 2182 | FlushAllRegs(); |
| 2183 | LIR* inst = CheckSuspendUsingLoad(); |
| 2184 | MarkSafepointPC(inst); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2185 | OpUnconditionalBranch(target); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2186 | } |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2187 | } |
| 2188 | |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 2189 | /* Call out to helper assembly routine that will null check obj and then lock it. */ |
| 2190 | void Mir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) { |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 2191 | UNUSED(opt_flags); // TODO: avoid null check with specialized non-null helper. |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 2192 | FlushAllRegs(); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2193 | CallRuntimeHelperRegLocation(kQuickLockObject, rl_src, true); |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 2194 | } |
| 2195 | |
| 2196 | /* Call out to helper assembly routine that will null check obj and then unlock it. */ |
| 2197 | void Mir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) { |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 2198 | UNUSED(opt_flags); // TODO: avoid null check with specialized non-null helper. |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 2199 | FlushAllRegs(); |
Andreas Gampe | 9843059 | 2014-07-27 19:44:50 -0700 | [diff] [blame] | 2200 | CallRuntimeHelperRegLocation(kQuickUnlockObject, rl_src, true); |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 2201 | } |
| 2202 | |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 2203 | /* Generic code for generating a wide constant into a VR. */ |
| 2204 | void Mir2Lir::GenConstWide(RegLocation rl_dest, int64_t value) { |
| 2205 | RegLocation rl_result = EvalLoc(rl_dest, kAnyReg, true); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 2206 | LoadConstantWide(rl_result.reg, value); |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 2207 | StoreValueWide(rl_dest, rl_result); |
| 2208 | } |
| 2209 | |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2210 | void Mir2Lir::GenSmallPackedSwitch(MIR* mir, DexOffset table_offset, RegLocation rl_src) { |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2211 | BasicBlock* bb = mir_graph_->GetBasicBlock(mir->bb); |
| 2212 | DCHECK(bb != nullptr); |
| 2213 | ArenaVector<SuccessorBlockInfo*>::const_iterator succ_bb_iter = bb->successor_blocks.cbegin(); |
Razvan A Lupusoru | 8d0d03e | 2014-06-06 17:04:52 -0700 | [diff] [blame] | 2214 | const uint16_t* table = mir_graph_->GetTable(mir, table_offset); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2215 | const uint16_t entries = table[1]; |
| 2216 | // Chained cmp-and-branch. |
| 2217 | const int32_t* as_int32 = reinterpret_cast<const int32_t*>(&table[2]); |
Ian Rogers | 7d4ecd5 | 2014-10-30 15:10:02 -0700 | [diff] [blame] | 2218 | int32_t starting_key = as_int32[0]; |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2219 | rl_src = LoadValue(rl_src, kCoreReg); |
| 2220 | int i = 0; |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2221 | for (; i < entries; ++i, ++succ_bb_iter) { |
Ian Rogers | 7d4ecd5 | 2014-10-30 15:10:02 -0700 | [diff] [blame] | 2222 | if (!InexpensiveConstantInt(starting_key + i, Instruction::Code::IF_EQ)) { |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2223 | // Switch to using a temp and add. |
| 2224 | break; |
| 2225 | } |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2226 | SuccessorBlockInfo* successor_block_info = *succ_bb_iter; |
| 2227 | DCHECK(successor_block_info != nullptr); |
| 2228 | int case_block_id = successor_block_info->block; |
| 2229 | DCHECK_EQ(starting_key + i, successor_block_info->key); |
| 2230 | OpCmpImmBranch(kCondEq, rl_src.reg, starting_key + i, &block_label_list_[case_block_id]); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2231 | } |
| 2232 | if (i < entries) { |
| 2233 | // The rest do not seem to be inexpensive. Try to allocate a temp and use add. |
| 2234 | RegStorage key_temp = AllocTypedTemp(false, kCoreReg, false); |
| 2235 | if (key_temp.Valid()) { |
Ian Rogers | 7d4ecd5 | 2014-10-30 15:10:02 -0700 | [diff] [blame] | 2236 | LoadConstantNoClobber(key_temp, starting_key + i); |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2237 | for (; i < entries - 1; ++i, ++succ_bb_iter) { |
| 2238 | SuccessorBlockInfo* successor_block_info = *succ_bb_iter; |
| 2239 | DCHECK(successor_block_info != nullptr); |
| 2240 | int case_block_id = successor_block_info->block; |
| 2241 | DCHECK_EQ(starting_key + i, successor_block_info->key); |
| 2242 | OpCmpBranch(kCondEq, rl_src.reg, key_temp, &block_label_list_[case_block_id]); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2243 | OpRegImm(kOpAdd, key_temp, 1); // Increment key. |
| 2244 | } |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2245 | SuccessorBlockInfo* successor_block_info = *succ_bb_iter; |
| 2246 | DCHECK(successor_block_info != nullptr); |
| 2247 | int case_block_id = successor_block_info->block; |
| 2248 | DCHECK_EQ(starting_key + i, successor_block_info->key); |
| 2249 | OpCmpBranch(kCondEq, rl_src.reg, key_temp, &block_label_list_[case_block_id]); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2250 | } else { |
| 2251 | // No free temp, just finish the old loop. |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2252 | for (; i < entries; ++i, ++succ_bb_iter) { |
| 2253 | SuccessorBlockInfo* successor_block_info = *succ_bb_iter; |
| 2254 | DCHECK(successor_block_info != nullptr); |
| 2255 | int case_block_id = successor_block_info->block; |
| 2256 | DCHECK_EQ(starting_key + i, successor_block_info->key); |
| 2257 | OpCmpImmBranch(kCondEq, rl_src.reg, starting_key + i, &block_label_list_[case_block_id]); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2258 | } |
| 2259 | } |
| 2260 | } |
| 2261 | } |
| 2262 | |
| 2263 | void Mir2Lir::GenPackedSwitch(MIR* mir, DexOffset table_offset, RegLocation rl_src) { |
Razvan A Lupusoru | 8d0d03e | 2014-06-06 17:04:52 -0700 | [diff] [blame] | 2264 | const uint16_t* table = mir_graph_->GetTable(mir, table_offset); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2265 | if (cu_->verbose) { |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2266 | DumpPackedSwitchTable(table); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2267 | } |
| 2268 | |
| 2269 | const uint16_t entries = table[1]; |
| 2270 | if (entries <= kSmallSwitchThreshold) { |
| 2271 | GenSmallPackedSwitch(mir, table_offset, rl_src); |
| 2272 | } else { |
| 2273 | // Use the backend-specific implementation. |
| 2274 | GenLargePackedSwitch(mir, table_offset, rl_src); |
| 2275 | } |
| 2276 | } |
| 2277 | |
| 2278 | void Mir2Lir::GenSmallSparseSwitch(MIR* mir, DexOffset table_offset, RegLocation rl_src) { |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2279 | BasicBlock* bb = mir_graph_->GetBasicBlock(mir->bb); |
| 2280 | DCHECK(bb != nullptr); |
Razvan A Lupusoru | 8d0d03e | 2014-06-06 17:04:52 -0700 | [diff] [blame] | 2281 | const uint16_t* table = mir_graph_->GetTable(mir, table_offset); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2282 | const uint16_t entries = table[1]; |
| 2283 | // Chained cmp-and-branch. |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2284 | rl_src = LoadValue(rl_src, kCoreReg); |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2285 | int i = 0; |
| 2286 | for (SuccessorBlockInfo* successor_block_info : bb->successor_blocks) { |
| 2287 | int case_block_id = successor_block_info->block; |
| 2288 | int key = successor_block_info->key; |
| 2289 | OpCmpImmBranch(kCondEq, rl_src.reg, key, &block_label_list_[case_block_id]); |
| 2290 | i++; |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2291 | } |
Chao-ying Fu | da96aed | 2014-10-27 14:42:00 -0700 | [diff] [blame] | 2292 | DCHECK_EQ(i, entries); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2293 | } |
| 2294 | |
| 2295 | void Mir2Lir::GenSparseSwitch(MIR* mir, DexOffset table_offset, RegLocation rl_src) { |
Razvan A Lupusoru | 8d0d03e | 2014-06-06 17:04:52 -0700 | [diff] [blame] | 2296 | const uint16_t* table = mir_graph_->GetTable(mir, table_offset); |
Andreas Gampe | 48971b3 | 2014-08-06 10:09:01 -0700 | [diff] [blame] | 2297 | if (cu_->verbose) { |
| 2298 | DumpSparseSwitchTable(table); |
| 2299 | } |
| 2300 | |
| 2301 | const uint16_t entries = table[1]; |
| 2302 | if (entries <= kSmallSwitchThreshold) { |
| 2303 | GenSmallSparseSwitch(mir, table_offset, rl_src); |
| 2304 | } else { |
| 2305 | // Use the backend-specific implementation. |
| 2306 | GenLargeSparseSwitch(mir, table_offset, rl_src); |
| 2307 | } |
| 2308 | } |
| 2309 | |
Fred Shih | 37f05ef | 2014-07-16 18:38:08 -0700 | [diff] [blame] | 2310 | bool Mir2Lir::SizeMatchesTypeForEntrypoint(OpSize size, Primitive::Type type) { |
| 2311 | switch (size) { |
| 2312 | case kReference: |
| 2313 | return type == Primitive::kPrimNot; |
| 2314 | case k64: |
| 2315 | case kDouble: |
| 2316 | return type == Primitive::kPrimLong || type == Primitive::kPrimDouble; |
| 2317 | case k32: |
| 2318 | case kSingle: |
| 2319 | return type == Primitive::kPrimInt || type == Primitive::kPrimFloat; |
| 2320 | case kSignedHalf: |
| 2321 | return type == Primitive::kPrimShort; |
| 2322 | case kUnsignedHalf: |
| 2323 | return type == Primitive::kPrimChar; |
| 2324 | case kSignedByte: |
| 2325 | return type == Primitive::kPrimByte; |
| 2326 | case kUnsignedByte: |
| 2327 | return type == Primitive::kPrimBoolean; |
| 2328 | case kWord: // Intentional fallthrough. |
| 2329 | default: |
| 2330 | return false; // There are no sane types with this op size. |
| 2331 | } |
| 2332 | } |
| 2333 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 2334 | } // namespace art |