int_x86.cc revision 2689fbad6b5ec1ae8f8c8791a80c6fd3cf24144d
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 */ 16 17/* This file contains codegen for the X86 ISA */ 18 19#include "codegen_x86.h" 20#include "dex/quick/mir_to_lir-inl.h" 21#include "mirror/array.h" 22#include "x86_lir.h" 23 24namespace art { 25 26/* 27 * Compare two 64-bit values 28 * x = y return 0 29 * x < y return -1 30 * x > y return 1 31 */ 32void X86Mir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1, 33 RegLocation rl_src2) { 34 if (Gen64Bit()) { 35 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 36 rl_src2 = LoadValueWide(rl_src2, kCoreReg); 37 RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); 38 RegStorage temp_reg = AllocTemp(); 39 OpRegReg(kOpCmp, rl_src1.reg, rl_src2.reg); 40 NewLIR2(kX86Set8R, rl_result.reg.GetReg(), kX86CondG); // result = (src1 > src2) ? 1 : 0 41 NewLIR2(kX86Set8R, temp_reg.GetReg(), kX86CondL); // temp = (src1 >= src2) ? 0 : 1 42 NewLIR2(kX86Sub8RR, rl_result.reg.GetReg(), temp_reg.GetReg()); 43 NewLIR2(kX86Movsx8qRR, rl_result.reg.GetReg(), rl_result.reg.GetReg()); 44 45 StoreValue(rl_dest, rl_result); 46 FreeTemp(temp_reg); 47 return; 48 } 49 50 FlushAllRegs(); 51 LockCallTemps(); // Prepare for explicit register usage 52 RegStorage r_tmp1 = RegStorage::MakeRegPair(rs_r0, rs_r1); 53 RegStorage r_tmp2 = RegStorage::MakeRegPair(rs_r2, rs_r3); 54 LoadValueDirectWideFixed(rl_src1, r_tmp1); 55 LoadValueDirectWideFixed(rl_src2, r_tmp2); 56 // Compute (r1:r0) = (r1:r0) - (r3:r2) 57 OpRegReg(kOpSub, rs_r0, rs_r2); // r0 = r0 - r2 58 OpRegReg(kOpSbc, rs_r1, rs_r3); // r1 = r1 - r3 - CF 59 NewLIR2(kX86Set8R, rs_r2.GetReg(), kX86CondL); // r2 = (r1:r0) < (r3:r2) ? 1 : 0 60 NewLIR2(kX86Movzx8RR, rs_r2.GetReg(), rs_r2.GetReg()); 61 OpReg(kOpNeg, rs_r2); // r2 = -r2 62 OpRegReg(kOpOr, rs_r0, rs_r1); // r0 = high | low - sets ZF 63 NewLIR2(kX86Set8R, rs_r0.GetReg(), kX86CondNz); // r0 = (r1:r0) != (r3:r2) ? 1 : 0 64 NewLIR2(kX86Movzx8RR, r0, r0); 65 OpRegReg(kOpOr, rs_r0, rs_r2); // r0 = r0 | r2 66 RegLocation rl_result = LocCReturn(); 67 StoreValue(rl_dest, rl_result); 68} 69 70X86ConditionCode X86ConditionEncoding(ConditionCode cond) { 71 switch (cond) { 72 case kCondEq: return kX86CondEq; 73 case kCondNe: return kX86CondNe; 74 case kCondCs: return kX86CondC; 75 case kCondCc: return kX86CondNc; 76 case kCondUlt: return kX86CondC; 77 case kCondUge: return kX86CondNc; 78 case kCondMi: return kX86CondS; 79 case kCondPl: return kX86CondNs; 80 case kCondVs: return kX86CondO; 81 case kCondVc: return kX86CondNo; 82 case kCondHi: return kX86CondA; 83 case kCondLs: return kX86CondBe; 84 case kCondGe: return kX86CondGe; 85 case kCondLt: return kX86CondL; 86 case kCondGt: return kX86CondG; 87 case kCondLe: return kX86CondLe; 88 case kCondAl: 89 case kCondNv: LOG(FATAL) << "Should not reach here"; 90 } 91 return kX86CondO; 92} 93 94LIR* X86Mir2Lir::OpCmpBranch(ConditionCode cond, RegStorage src1, RegStorage src2, LIR* target) { 95 NewLIR2(kX86Cmp32RR, src1.GetReg(), src2.GetReg()); 96 X86ConditionCode cc = X86ConditionEncoding(cond); 97 LIR* branch = NewLIR2(kX86Jcc8, 0 /* lir operand for Jcc offset */ , 98 cc); 99 branch->target = target; 100 return branch; 101} 102 103LIR* X86Mir2Lir::OpCmpImmBranch(ConditionCode cond, RegStorage reg, 104 int check_value, LIR* target) { 105 if ((check_value == 0) && (cond == kCondEq || cond == kCondNe)) { 106 // TODO: when check_value == 0 and reg is rCX, use the jcxz/nz opcode 107 NewLIR2(kX86Test32RR, reg.GetReg(), reg.GetReg()); 108 } else { 109 NewLIR2(IS_SIMM8(check_value) ? kX86Cmp32RI8 : kX86Cmp32RI, reg.GetReg(), check_value); 110 } 111 X86ConditionCode cc = X86ConditionEncoding(cond); 112 LIR* branch = NewLIR2(kX86Jcc8, 0 /* lir operand for Jcc offset */ , cc); 113 branch->target = target; 114 return branch; 115} 116 117LIR* X86Mir2Lir::OpRegCopyNoInsert(RegStorage r_dest, RegStorage r_src) { 118 // If src or dest is a pair, we'll be using low reg. 119 if (r_dest.IsPair()) { 120 r_dest = r_dest.GetLow(); 121 } 122 if (r_src.IsPair()) { 123 r_src = r_src.GetLow(); 124 } 125 if (r_dest.IsFloat() || r_src.IsFloat()) 126 return OpFpRegCopy(r_dest, r_src); 127 LIR* res = RawLIR(current_dalvik_offset_, r_dest.Is64Bit() ? kX86Mov64RR : kX86Mov32RR, 128 r_dest.GetReg(), r_src.GetReg()); 129 if (!(cu_->disable_opt & (1 << kSafeOptimizations)) && r_dest == r_src) { 130 res->flags.is_nop = true; 131 } 132 return res; 133} 134 135void X86Mir2Lir::OpRegCopy(RegStorage r_dest, RegStorage r_src) { 136 if (r_dest != r_src) { 137 LIR *res = OpRegCopyNoInsert(r_dest, r_src); 138 AppendLIR(res); 139 } 140} 141 142void X86Mir2Lir::OpRegCopyWide(RegStorage r_dest, RegStorage r_src) { 143 if (r_dest != r_src) { 144 bool dest_fp = r_dest.IsFloat(); 145 bool src_fp = r_src.IsFloat(); 146 if (dest_fp) { 147 if (src_fp) { 148 OpRegCopy(r_dest, r_src); 149 } else { 150 // TODO: Prevent this from happening in the code. The result is often 151 // unused or could have been loaded more easily from memory. 152 if (!r_src.IsPair()) { 153 DCHECK(!r_dest.IsPair()); 154 NewLIR2(kX86MovqxrRR, r_dest.GetReg(), r_src.GetReg()); 155 } else { 156 NewLIR2(kX86MovdxrRR, r_dest.GetReg(), r_src.GetLowReg()); 157 RegStorage r_tmp = AllocTempDouble(); 158 NewLIR2(kX86MovdxrRR, r_tmp.GetReg(), r_src.GetHighReg()); 159 NewLIR2(kX86PunpckldqRR, r_dest.GetReg(), r_tmp.GetReg()); 160 FreeTemp(r_tmp); 161 } 162 } 163 } else { 164 if (src_fp) { 165 if (!r_dest.IsPair()) { 166 DCHECK(!r_src.IsPair()); 167 NewLIR2(kX86MovqrxRR, r_dest.GetReg(), r_src.GetReg()); 168 } else { 169 NewLIR2(kX86MovdrxRR, r_dest.GetLowReg(), r_src.GetReg()); 170 RegStorage temp_reg = AllocTempDouble(); 171 NewLIR2(kX86MovsdRR, temp_reg.GetReg(), r_src.GetReg()); 172 NewLIR2(kX86PsrlqRI, temp_reg.GetReg(), 32); 173 NewLIR2(kX86MovdrxRR, r_dest.GetHighReg(), temp_reg.GetReg()); 174 } 175 } else { 176 DCHECK_EQ(r_dest.IsPair(), r_src.IsPair()); 177 if (!r_src.IsPair()) { 178 // Just copy the register directly. 179 OpRegCopy(r_dest, r_src); 180 } else { 181 // Handle overlap 182 if (r_src.GetHighReg() == r_dest.GetLowReg() && 183 r_src.GetLowReg() == r_dest.GetHighReg()) { 184 // Deal with cycles. 185 RegStorage temp_reg = AllocTemp(); 186 OpRegCopy(temp_reg, r_dest.GetHigh()); 187 OpRegCopy(r_dest.GetHigh(), r_dest.GetLow()); 188 OpRegCopy(r_dest.GetLow(), temp_reg); 189 FreeTemp(temp_reg); 190 } else if (r_src.GetHighReg() == r_dest.GetLowReg()) { 191 OpRegCopy(r_dest.GetHigh(), r_src.GetHigh()); 192 OpRegCopy(r_dest.GetLow(), r_src.GetLow()); 193 } else { 194 OpRegCopy(r_dest.GetLow(), r_src.GetLow()); 195 OpRegCopy(r_dest.GetHigh(), r_src.GetHigh()); 196 } 197 } 198 } 199 } 200 } 201} 202 203void X86Mir2Lir::GenSelect(BasicBlock* bb, MIR* mir) { 204 RegLocation rl_result; 205 RegLocation rl_src = mir_graph_->GetSrc(mir, 0); 206 RegLocation rl_dest = mir_graph_->GetDest(mir); 207 // Avoid using float regs here. 208 RegisterClass src_reg_class = rl_src.ref ? kRefReg : kCoreReg; 209 RegisterClass result_reg_class = rl_dest.ref ? kRefReg : kCoreReg; 210 rl_src = LoadValue(rl_src, src_reg_class); 211 ConditionCode ccode = mir->meta.ccode; 212 213 // The kMirOpSelect has two variants, one for constants and one for moves. 214 const bool is_constant_case = (mir->ssa_rep->num_uses == 1); 215 216 if (is_constant_case) { 217 int true_val = mir->dalvikInsn.vB; 218 int false_val = mir->dalvikInsn.vC; 219 rl_result = EvalLoc(rl_dest, result_reg_class, true); 220 221 /* 222 * For ccode == kCondEq: 223 * 224 * 1) When the true case is zero and result_reg is not same as src_reg: 225 * xor result_reg, result_reg 226 * cmp $0, src_reg 227 * mov t1, $false_case 228 * cmovnz result_reg, t1 229 * 2) When the false case is zero and result_reg is not same as src_reg: 230 * xor result_reg, result_reg 231 * cmp $0, src_reg 232 * mov t1, $true_case 233 * cmovz result_reg, t1 234 * 3) All other cases (we do compare first to set eflags): 235 * cmp $0, src_reg 236 * mov result_reg, $false_case 237 * mov t1, $true_case 238 * cmovz result_reg, t1 239 */ 240 // FIXME: depending on how you use registers you could get a false != mismatch when dealing 241 // with different views of the same underlying physical resource (i.e. solo32 vs. solo64). 242 const bool result_reg_same_as_src = 243 (rl_src.location == kLocPhysReg && rl_src.reg.GetReg() == rl_result.reg.GetReg()); 244 const bool true_zero_case = (true_val == 0 && false_val != 0 && !result_reg_same_as_src); 245 const bool false_zero_case = (false_val == 0 && true_val != 0 && !result_reg_same_as_src); 246 const bool catch_all_case = !(true_zero_case || false_zero_case); 247 248 if (true_zero_case || false_zero_case) { 249 OpRegReg(kOpXor, rl_result.reg, rl_result.reg); 250 } 251 252 if (true_zero_case || false_zero_case || catch_all_case) { 253 OpRegImm(kOpCmp, rl_src.reg, 0); 254 } 255 256 if (catch_all_case) { 257 OpRegImm(kOpMov, rl_result.reg, false_val); 258 } 259 260 if (true_zero_case || false_zero_case || catch_all_case) { 261 ConditionCode cc = true_zero_case ? NegateComparison(ccode) : ccode; 262 int immediateForTemp = true_zero_case ? false_val : true_val; 263 RegStorage temp1_reg = AllocTypedTemp(false, result_reg_class); 264 OpRegImm(kOpMov, temp1_reg, immediateForTemp); 265 266 OpCondRegReg(kOpCmov, cc, rl_result.reg, temp1_reg); 267 268 FreeTemp(temp1_reg); 269 } 270 } else { 271 RegLocation rl_true = mir_graph_->GetSrc(mir, 1); 272 RegLocation rl_false = mir_graph_->GetSrc(mir, 2); 273 rl_true = LoadValue(rl_true, result_reg_class); 274 rl_false = LoadValue(rl_false, result_reg_class); 275 rl_result = EvalLoc(rl_dest, result_reg_class, true); 276 277 /* 278 * For ccode == kCondEq: 279 * 280 * 1) When true case is already in place: 281 * cmp $0, src_reg 282 * cmovnz result_reg, false_reg 283 * 2) When false case is already in place: 284 * cmp $0, src_reg 285 * cmovz result_reg, true_reg 286 * 3) When neither cases are in place: 287 * cmp $0, src_reg 288 * mov result_reg, false_reg 289 * cmovz result_reg, true_reg 290 */ 291 292 // kMirOpSelect is generated just for conditional cases when comparison is done with zero. 293 OpRegImm(kOpCmp, rl_src.reg, 0); 294 295 if (rl_result.reg.GetReg() == rl_true.reg.GetReg()) { 296 OpCondRegReg(kOpCmov, NegateComparison(ccode), rl_result.reg, rl_false.reg); 297 } else if (rl_result.reg.GetReg() == rl_false.reg.GetReg()) { 298 OpCondRegReg(kOpCmov, ccode, rl_result.reg, rl_true.reg); 299 } else { 300 OpRegCopy(rl_result.reg, rl_false.reg); 301 OpCondRegReg(kOpCmov, ccode, rl_result.reg, rl_true.reg); 302 } 303 } 304 305 StoreValue(rl_dest, rl_result); 306} 307 308void X86Mir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir) { 309 LIR* taken = &block_label_list_[bb->taken]; 310 RegLocation rl_src1 = mir_graph_->GetSrcWide(mir, 0); 311 RegLocation rl_src2 = mir_graph_->GetSrcWide(mir, 2); 312 ConditionCode ccode = mir->meta.ccode; 313 314 if (rl_src1.is_const) { 315 std::swap(rl_src1, rl_src2); 316 ccode = FlipComparisonOrder(ccode); 317 } 318 if (rl_src2.is_const) { 319 // Do special compare/branch against simple const operand 320 int64_t val = mir_graph_->ConstantValueWide(rl_src2); 321 GenFusedLongCmpImmBranch(bb, rl_src1, val, ccode); 322 return; 323 } 324 325 if (Gen64Bit()) { 326 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 327 rl_src2 = LoadValueWide(rl_src2, kCoreReg); 328 329 OpRegReg(kOpCmp, rl_src1.reg, rl_src2.reg); 330 OpCondBranch(ccode, taken); 331 return; 332 } 333 334 FlushAllRegs(); 335 LockCallTemps(); // Prepare for explicit register usage 336 RegStorage r_tmp1 = RegStorage::MakeRegPair(rs_r0, rs_r1); 337 RegStorage r_tmp2 = RegStorage::MakeRegPair(rs_r2, rs_r3); 338 LoadValueDirectWideFixed(rl_src1, r_tmp1); 339 LoadValueDirectWideFixed(rl_src2, r_tmp2); 340 341 // Swap operands and condition code to prevent use of zero flag. 342 if (ccode == kCondLe || ccode == kCondGt) { 343 // Compute (r3:r2) = (r3:r2) - (r1:r0) 344 OpRegReg(kOpSub, rs_r2, rs_r0); // r2 = r2 - r0 345 OpRegReg(kOpSbc, rs_r3, rs_r1); // r3 = r3 - r1 - CF 346 } else { 347 // Compute (r1:r0) = (r1:r0) - (r3:r2) 348 OpRegReg(kOpSub, rs_r0, rs_r2); // r0 = r0 - r2 349 OpRegReg(kOpSbc, rs_r1, rs_r3); // r1 = r1 - r3 - CF 350 } 351 switch (ccode) { 352 case kCondEq: 353 case kCondNe: 354 OpRegReg(kOpOr, rs_r0, rs_r1); // r0 = r0 | r1 355 break; 356 case kCondLe: 357 ccode = kCondGe; 358 break; 359 case kCondGt: 360 ccode = kCondLt; 361 break; 362 case kCondLt: 363 case kCondGe: 364 break; 365 default: 366 LOG(FATAL) << "Unexpected ccode: " << ccode; 367 } 368 OpCondBranch(ccode, taken); 369} 370 371void X86Mir2Lir::GenFusedLongCmpImmBranch(BasicBlock* bb, RegLocation rl_src1, 372 int64_t val, ConditionCode ccode) { 373 int32_t val_lo = Low32Bits(val); 374 int32_t val_hi = High32Bits(val); 375 LIR* taken = &block_label_list_[bb->taken]; 376 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 377 bool is_equality_test = ccode == kCondEq || ccode == kCondNe; 378 379 if (Gen64Bit()) { 380 if (is_equality_test && val == 0) { 381 // We can simplify of comparing for ==, != to 0. 382 NewLIR2(kX86Test64RR, rl_src1.reg.GetReg(), rl_src1.reg.GetReg()); 383 } else if (is_equality_test && val_hi == 0 && val_lo > 0) { 384 OpRegImm(kOpCmp, rl_src1.reg, val_lo); 385 } else { 386 RegStorage tmp = AllocTypedTempWide(false, kCoreReg); 387 LoadConstantWide(tmp, val); 388 OpRegReg(kOpCmp, rl_src1.reg, tmp); 389 FreeTemp(tmp); 390 } 391 OpCondBranch(ccode, taken); 392 return; 393 } 394 395 if (is_equality_test && val != 0) { 396 rl_src1 = ForceTempWide(rl_src1); 397 } 398 RegStorage low_reg = rl_src1.reg.GetLow(); 399 RegStorage high_reg = rl_src1.reg.GetHigh(); 400 401 if (is_equality_test) { 402 // We can simplify of comparing for ==, != to 0. 403 if (val == 0) { 404 if (IsTemp(low_reg)) { 405 OpRegReg(kOpOr, low_reg, high_reg); 406 // We have now changed it; ignore the old values. 407 Clobber(rl_src1.reg); 408 } else { 409 RegStorage t_reg = AllocTemp(); 410 OpRegRegReg(kOpOr, t_reg, low_reg, high_reg); 411 FreeTemp(t_reg); 412 } 413 OpCondBranch(ccode, taken); 414 return; 415 } 416 417 // Need to compute the actual value for ==, !=. 418 OpRegImm(kOpSub, low_reg, val_lo); 419 NewLIR2(kX86Sbb32RI, high_reg.GetReg(), val_hi); 420 OpRegReg(kOpOr, high_reg, low_reg); 421 Clobber(rl_src1.reg); 422 } else if (ccode == kCondLe || ccode == kCondGt) { 423 // Swap operands and condition code to prevent use of zero flag. 424 RegStorage tmp = AllocTypedTempWide(false, kCoreReg); 425 LoadConstantWide(tmp, val); 426 OpRegReg(kOpSub, tmp.GetLow(), low_reg); 427 OpRegReg(kOpSbc, tmp.GetHigh(), high_reg); 428 ccode = (ccode == kCondLe) ? kCondGe : kCondLt; 429 FreeTemp(tmp); 430 } else { 431 // We can use a compare for the low word to set CF. 432 OpRegImm(kOpCmp, low_reg, val_lo); 433 if (IsTemp(high_reg)) { 434 NewLIR2(kX86Sbb32RI, high_reg.GetReg(), val_hi); 435 // We have now changed it; ignore the old values. 436 Clobber(rl_src1.reg); 437 } else { 438 // mov temp_reg, high_reg; sbb temp_reg, high_constant 439 RegStorage t_reg = AllocTemp(); 440 OpRegCopy(t_reg, high_reg); 441 NewLIR2(kX86Sbb32RI, t_reg.GetReg(), val_hi); 442 FreeTemp(t_reg); 443 } 444 } 445 446 OpCondBranch(ccode, taken); 447} 448 449void X86Mir2Lir::CalculateMagicAndShift(int divisor, int& magic, int& shift) { 450 // It does not make sense to calculate magic and shift for zero divisor. 451 DCHECK_NE(divisor, 0); 452 453 /* According to H.S.Warren's Hacker's Delight Chapter 10 and 454 * T,Grablund, P.L.Montogomery's Division by invariant integers using multiplication. 455 * The magic number M and shift S can be calculated in the following way: 456 * Let nc be the most positive value of numerator(n) such that nc = kd - 1, 457 * where divisor(d) >=2. 458 * Let nc be the most negative value of numerator(n) such that nc = kd + 1, 459 * where divisor(d) <= -2. 460 * Thus nc can be calculated like: 461 * nc = 2^31 + 2^31 % d - 1, where d >= 2 462 * nc = -2^31 + (2^31 + 1) % d, where d >= 2. 463 * 464 * So the shift p is the smallest p satisfying 465 * 2^p > nc * (d - 2^p % d), where d >= 2 466 * 2^p > nc * (d + 2^p % d), where d <= -2. 467 * 468 * the magic number M is calcuated by 469 * M = (2^p + d - 2^p % d) / d, where d >= 2 470 * M = (2^p - d - 2^p % d) / d, where d <= -2. 471 * 472 * Notice that p is always bigger than or equal to 32, so we just return 32-p as 473 * the shift number S. 474 */ 475 476 int32_t p = 31; 477 const uint32_t two31 = 0x80000000U; 478 479 // Initialize the computations. 480 uint32_t abs_d = (divisor >= 0) ? divisor : -divisor; 481 uint32_t tmp = two31 + (static_cast<uint32_t>(divisor) >> 31); 482 uint32_t abs_nc = tmp - 1 - tmp % abs_d; 483 uint32_t quotient1 = two31 / abs_nc; 484 uint32_t remainder1 = two31 % abs_nc; 485 uint32_t quotient2 = two31 / abs_d; 486 uint32_t remainder2 = two31 % abs_d; 487 488 /* 489 * To avoid handling both positive and negative divisor, Hacker's Delight 490 * introduces a method to handle these 2 cases together to avoid duplication. 491 */ 492 uint32_t delta; 493 do { 494 p++; 495 quotient1 = 2 * quotient1; 496 remainder1 = 2 * remainder1; 497 if (remainder1 >= abs_nc) { 498 quotient1++; 499 remainder1 = remainder1 - abs_nc; 500 } 501 quotient2 = 2 * quotient2; 502 remainder2 = 2 * remainder2; 503 if (remainder2 >= abs_d) { 504 quotient2++; 505 remainder2 = remainder2 - abs_d; 506 } 507 delta = abs_d - remainder2; 508 } while (quotient1 < delta || (quotient1 == delta && remainder1 == 0)); 509 510 magic = (divisor > 0) ? (quotient2 + 1) : (-quotient2 - 1); 511 shift = p - 32; 512} 513 514RegLocation X86Mir2Lir::GenDivRemLit(RegLocation rl_dest, RegStorage reg_lo, int lit, bool is_div) { 515 LOG(FATAL) << "Unexpected use of GenDivRemLit for x86"; 516 return rl_dest; 517} 518 519RegLocation X86Mir2Lir::GenDivRemLit(RegLocation rl_dest, RegLocation rl_src, 520 int imm, bool is_div) { 521 // Use a multiply (and fixup) to perform an int div/rem by a constant. 522 523 // We have to use fixed registers, so flush all the temps. 524 FlushAllRegs(); 525 LockCallTemps(); // Prepare for explicit register usage. 526 527 // Assume that the result will be in EDX. 528 RegLocation rl_result = {kLocPhysReg, 0, 0, 0, 0, 0, 0, 0, 1, rs_r2, INVALID_SREG, INVALID_SREG}; 529 530 // handle div/rem by 1 special case. 531 if (imm == 1) { 532 if (is_div) { 533 // x / 1 == x. 534 StoreValue(rl_result, rl_src); 535 } else { 536 // x % 1 == 0. 537 LoadConstantNoClobber(rs_r0, 0); 538 // For this case, return the result in EAX. 539 rl_result.reg.SetReg(r0); 540 } 541 } else if (imm == -1) { // handle 0x80000000 / -1 special case. 542 if (is_div) { 543 LIR *minint_branch = 0; 544 LoadValueDirectFixed(rl_src, rs_r0); 545 OpRegImm(kOpCmp, rs_r0, 0x80000000); 546 minint_branch = NewLIR2(kX86Jcc8, 0, kX86CondEq); 547 548 // for x != MIN_INT, x / -1 == -x. 549 NewLIR1(kX86Neg32R, r0); 550 551 LIR* branch_around = NewLIR1(kX86Jmp8, 0); 552 // The target for cmp/jmp above. 553 minint_branch->target = NewLIR0(kPseudoTargetLabel); 554 // EAX already contains the right value (0x80000000), 555 branch_around->target = NewLIR0(kPseudoTargetLabel); 556 } else { 557 // x % -1 == 0. 558 LoadConstantNoClobber(rs_r0, 0); 559 } 560 // For this case, return the result in EAX. 561 rl_result.reg.SetReg(r0); 562 } else { 563 CHECK(imm <= -2 || imm >= 2); 564 // Use H.S.Warren's Hacker's Delight Chapter 10 and 565 // T,Grablund, P.L.Montogomery's Division by invariant integers using multiplication. 566 int magic, shift; 567 CalculateMagicAndShift(imm, magic, shift); 568 569 /* 570 * For imm >= 2, 571 * int(n/imm) = floor(n/imm) = floor(M*n/2^S), while n > 0 572 * int(n/imm) = ceil(n/imm) = floor(M*n/2^S) +1, while n < 0. 573 * For imm <= -2, 574 * int(n/imm) = ceil(n/imm) = floor(M*n/2^S) +1 , while n > 0 575 * int(n/imm) = floor(n/imm) = floor(M*n/2^S), while n < 0. 576 * We implement this algorithm in the following way: 577 * 1. multiply magic number m and numerator n, get the higher 32bit result in EDX 578 * 2. if imm > 0 and magic < 0, add numerator to EDX 579 * if imm < 0 and magic > 0, sub numerator from EDX 580 * 3. if S !=0, SAR S bits for EDX 581 * 4. add 1 to EDX if EDX < 0 582 * 5. Thus, EDX is the quotient 583 */ 584 585 // Numerator into EAX. 586 RegStorage numerator_reg; 587 if (!is_div || (imm > 0 && magic < 0) || (imm < 0 && magic > 0)) { 588 // We will need the value later. 589 if (rl_src.location == kLocPhysReg) { 590 // We can use it directly. 591 DCHECK(rl_src.reg.GetReg() != rs_r0.GetReg() && rl_src.reg.GetReg() != rs_r2.GetReg()); 592 numerator_reg = rl_src.reg; 593 } else { 594 numerator_reg = rs_r1; 595 LoadValueDirectFixed(rl_src, numerator_reg); 596 } 597 OpRegCopy(rs_r0, numerator_reg); 598 } else { 599 // Only need this once. Just put it into EAX. 600 LoadValueDirectFixed(rl_src, rs_r0); 601 } 602 603 // EDX = magic. 604 LoadConstantNoClobber(rs_r2, magic); 605 606 // EDX:EAX = magic & dividend. 607 NewLIR1(kX86Imul32DaR, rs_r2.GetReg()); 608 609 if (imm > 0 && magic < 0) { 610 // Add numerator to EDX. 611 DCHECK(numerator_reg.Valid()); 612 NewLIR2(kX86Add32RR, rs_r2.GetReg(), numerator_reg.GetReg()); 613 } else if (imm < 0 && magic > 0) { 614 DCHECK(numerator_reg.Valid()); 615 NewLIR2(kX86Sub32RR, rs_r2.GetReg(), numerator_reg.GetReg()); 616 } 617 618 // Do we need the shift? 619 if (shift != 0) { 620 // Shift EDX by 'shift' bits. 621 NewLIR2(kX86Sar32RI, rs_r2.GetReg(), shift); 622 } 623 624 // Add 1 to EDX if EDX < 0. 625 626 // Move EDX to EAX. 627 OpRegCopy(rs_r0, rs_r2); 628 629 // Move sign bit to bit 0, zeroing the rest. 630 NewLIR2(kX86Shr32RI, rs_r2.GetReg(), 31); 631 632 // EDX = EDX + EAX. 633 NewLIR2(kX86Add32RR, rs_r2.GetReg(), rs_r0.GetReg()); 634 635 // Quotient is in EDX. 636 if (!is_div) { 637 // We need to compute the remainder. 638 // Remainder is divisor - (quotient * imm). 639 DCHECK(numerator_reg.Valid()); 640 OpRegCopy(rs_r0, numerator_reg); 641 642 // EAX = numerator * imm. 643 OpRegRegImm(kOpMul, rs_r2, rs_r2, imm); 644 645 // EDX -= EAX. 646 NewLIR2(kX86Sub32RR, rs_r0.GetReg(), rs_r2.GetReg()); 647 648 // For this case, return the result in EAX. 649 rl_result.reg.SetReg(r0); 650 } 651 } 652 653 return rl_result; 654} 655 656RegLocation X86Mir2Lir::GenDivRem(RegLocation rl_dest, RegStorage reg_lo, RegStorage reg_hi, 657 bool is_div) { 658 LOG(FATAL) << "Unexpected use of GenDivRem for x86"; 659 return rl_dest; 660} 661 662RegLocation X86Mir2Lir::GenDivRem(RegLocation rl_dest, RegLocation rl_src1, 663 RegLocation rl_src2, bool is_div, bool check_zero) { 664 // We have to use fixed registers, so flush all the temps. 665 FlushAllRegs(); 666 LockCallTemps(); // Prepare for explicit register usage. 667 668 // Load LHS into EAX. 669 LoadValueDirectFixed(rl_src1, rs_r0); 670 671 // Load RHS into EBX. 672 LoadValueDirectFixed(rl_src2, rs_r1); 673 674 // Copy LHS sign bit into EDX. 675 NewLIR0(kx86Cdq32Da); 676 677 if (check_zero) { 678 // Handle division by zero case. 679 GenDivZeroCheck(rs_r1); 680 } 681 682 // Have to catch 0x80000000/-1 case, or we will get an exception! 683 OpRegImm(kOpCmp, rs_r1, -1); 684 LIR *minus_one_branch = NewLIR2(kX86Jcc8, 0, kX86CondNe); 685 686 // RHS is -1. 687 OpRegImm(kOpCmp, rs_r0, 0x80000000); 688 LIR * minint_branch = NewLIR2(kX86Jcc8, 0, kX86CondNe); 689 690 // In 0x80000000/-1 case. 691 if (!is_div) { 692 // For DIV, EAX is already right. For REM, we need EDX 0. 693 LoadConstantNoClobber(rs_r2, 0); 694 } 695 LIR* done = NewLIR1(kX86Jmp8, 0); 696 697 // Expected case. 698 minus_one_branch->target = NewLIR0(kPseudoTargetLabel); 699 minint_branch->target = minus_one_branch->target; 700 NewLIR1(kX86Idivmod32DaR, rs_r1.GetReg()); 701 done->target = NewLIR0(kPseudoTargetLabel); 702 703 // Result is in EAX for div and EDX for rem. 704 RegLocation rl_result = {kLocPhysReg, 0, 0, 0, 0, 0, 0, 0, 1, rs_r0, INVALID_SREG, INVALID_SREG}; 705 if (!is_div) { 706 rl_result.reg.SetReg(r2); 707 } 708 return rl_result; 709} 710 711bool X86Mir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min) { 712 DCHECK(cu_->instruction_set == kX86 || cu_->instruction_set == kX86_64); 713 714 // Get the two arguments to the invoke and place them in GP registers. 715 RegLocation rl_src1 = info->args[0]; 716 RegLocation rl_src2 = info->args[1]; 717 rl_src1 = LoadValue(rl_src1, kCoreReg); 718 rl_src2 = LoadValue(rl_src2, kCoreReg); 719 720 RegLocation rl_dest = InlineTarget(info); 721 RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); 722 723 /* 724 * If the result register is the same as the second element, then we need to be careful. 725 * The reason is that the first copy will inadvertently clobber the second element with 726 * the first one thus yielding the wrong result. Thus we do a swap in that case. 727 */ 728 if (rl_result.reg.GetReg() == rl_src2.reg.GetReg()) { 729 std::swap(rl_src1, rl_src2); 730 } 731 732 // Pick the first integer as min/max. 733 OpRegCopy(rl_result.reg, rl_src1.reg); 734 735 // If the integers are both in the same register, then there is nothing else to do 736 // because they are equal and we have already moved one into the result. 737 if (rl_src1.reg.GetReg() != rl_src2.reg.GetReg()) { 738 // It is possible we didn't pick correctly so do the actual comparison now. 739 OpRegReg(kOpCmp, rl_src1.reg, rl_src2.reg); 740 741 // Conditionally move the other integer into the destination register. 742 ConditionCode condition_code = is_min ? kCondGt : kCondLt; 743 OpCondRegReg(kOpCmov, condition_code, rl_result.reg, rl_src2.reg); 744 } 745 746 StoreValue(rl_dest, rl_result); 747 return true; 748} 749 750bool X86Mir2Lir::GenInlinedPeek(CallInfo* info, OpSize size) { 751 RegLocation rl_src_address = info->args[0]; // long address 752 rl_src_address = NarrowRegLoc(rl_src_address); // ignore high half in info->args[1] 753 RegLocation rl_dest = size == k64 ? InlineTargetWide(info) : InlineTarget(info); 754 RegLocation rl_address = LoadValue(rl_src_address, kCoreReg); 755 RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); 756 // Unaligned access is allowed on x86. 757 LoadBaseDisp(rl_address.reg, 0, rl_result.reg, size, kNotVolatile); 758 if (size == k64) { 759 StoreValueWide(rl_dest, rl_result); 760 } else { 761 DCHECK(size == kSignedByte || size == kSignedHalf || size == k32); 762 StoreValue(rl_dest, rl_result); 763 } 764 return true; 765} 766 767bool X86Mir2Lir::GenInlinedPoke(CallInfo* info, OpSize size) { 768 RegLocation rl_src_address = info->args[0]; // long address 769 rl_src_address = NarrowRegLoc(rl_src_address); // ignore high half in info->args[1] 770 RegLocation rl_src_value = info->args[2]; // [size] value 771 RegLocation rl_address = LoadValue(rl_src_address, kCoreReg); 772 if (size == k64) { 773 // Unaligned access is allowed on x86. 774 RegLocation rl_value = LoadValueWide(rl_src_value, kCoreReg); 775 StoreBaseDisp(rl_address.reg, 0, rl_value.reg, size, kNotVolatile); 776 } else { 777 DCHECK(size == kSignedByte || size == kSignedHalf || size == k32); 778 // Unaligned access is allowed on x86. 779 RegLocation rl_value = LoadValue(rl_src_value, kCoreReg); 780 StoreBaseDisp(rl_address.reg, 0, rl_value.reg, size, kNotVolatile); 781 } 782 return true; 783} 784 785void X86Mir2Lir::OpLea(RegStorage r_base, RegStorage reg1, RegStorage reg2, int scale, int offset) { 786 NewLIR5(kX86Lea32RA, r_base.GetReg(), reg1.GetReg(), reg2.GetReg(), scale, offset); 787} 788 789void X86Mir2Lir::OpTlsCmp(ThreadOffset<4> offset, int val) { 790 DCHECK_EQ(kX86, cu_->instruction_set); 791 NewLIR2(kX86Cmp16TI8, offset.Int32Value(), val); 792} 793 794void X86Mir2Lir::OpTlsCmp(ThreadOffset<8> offset, int val) { 795 DCHECK_EQ(kX86_64, cu_->instruction_set); 796 NewLIR2(kX86Cmp16TI8, offset.Int32Value(), val); 797} 798 799static bool IsInReg(X86Mir2Lir *pMir2Lir, const RegLocation &rl, RegStorage reg) { 800 return rl.reg.Valid() && rl.reg.GetReg() == reg.GetReg() && (pMir2Lir->IsLive(reg) || rl.home); 801} 802 803bool X86Mir2Lir::GenInlinedCas(CallInfo* info, bool is_long, bool is_object) { 804 DCHECK(cu_->instruction_set == kX86 || cu_->instruction_set == kX86_64); 805 // Unused - RegLocation rl_src_unsafe = info->args[0]; 806 RegLocation rl_src_obj = info->args[1]; // Object - known non-null 807 RegLocation rl_src_offset = info->args[2]; // long low 808 rl_src_offset = NarrowRegLoc(rl_src_offset); // ignore high half in info->args[3] 809 RegLocation rl_src_expected = info->args[4]; // int, long or Object 810 // If is_long, high half is in info->args[5] 811 RegLocation rl_src_new_value = info->args[is_long ? 6 : 5]; // int, long or Object 812 // If is_long, high half is in info->args[7] 813 814 if (is_long) { 815 // TODO: avoid unnecessary loads of SI and DI when the values are in registers. 816 // TODO: CFI support. 817 FlushAllRegs(); 818 LockCallTemps(); 819 RegStorage r_tmp1 = RegStorage::MakeRegPair(rs_rAX, rs_rDX); 820 RegStorage r_tmp2 = RegStorage::MakeRegPair(rs_rBX, rs_rCX); 821 LoadValueDirectWideFixed(rl_src_expected, r_tmp1); 822 LoadValueDirectWideFixed(rl_src_new_value, r_tmp2); 823 // FIXME: needs 64-bit update. 824 const bool obj_in_di = IsInReg(this, rl_src_obj, rs_rDI); 825 const bool obj_in_si = IsInReg(this, rl_src_obj, rs_rSI); 826 DCHECK(!obj_in_si || !obj_in_di); 827 const bool off_in_di = IsInReg(this, rl_src_offset, rs_rDI); 828 const bool off_in_si = IsInReg(this, rl_src_offset, rs_rSI); 829 DCHECK(!off_in_si || !off_in_di); 830 // If obj/offset is in a reg, use that reg. Otherwise, use the empty reg. 831 RegStorage rs_obj = obj_in_di ? rs_rDI : obj_in_si ? rs_rSI : !off_in_di ? rs_rDI : rs_rSI; 832 RegStorage rs_off = off_in_si ? rs_rSI : off_in_di ? rs_rDI : !obj_in_si ? rs_rSI : rs_rDI; 833 bool push_di = (!obj_in_di && !off_in_di) && (rs_obj == rs_rDI || rs_off == rs_rDI); 834 bool push_si = (!obj_in_si && !off_in_si) && (rs_obj == rs_rSI || rs_off == rs_rSI); 835 if (push_di) { 836 NewLIR1(kX86Push32R, rs_rDI.GetReg()); 837 MarkTemp(rs_rDI); 838 LockTemp(rs_rDI); 839 } 840 if (push_si) { 841 NewLIR1(kX86Push32R, rs_rSI.GetReg()); 842 MarkTemp(rs_rSI); 843 LockTemp(rs_rSI); 844 } 845 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 846 const size_t push_offset = (push_si ? 4u : 0u) + (push_di ? 4u : 0u); 847 if (!obj_in_si && !obj_in_di) { 848 LoadWordDisp(TargetReg(kSp), SRegOffset(rl_src_obj.s_reg_low) + push_offset, rs_obj); 849 // Dalvik register annotation in LoadBaseIndexedDisp() used wrong offset. Fix it. 850 DCHECK(!DECODE_ALIAS_INFO_WIDE(last_lir_insn_->flags.alias_info)); 851 int reg_id = DECODE_ALIAS_INFO_REG(last_lir_insn_->flags.alias_info) - push_offset / 4u; 852 AnnotateDalvikRegAccess(last_lir_insn_, reg_id, true, false); 853 } 854 if (!off_in_si && !off_in_di) { 855 LoadWordDisp(TargetReg(kSp), SRegOffset(rl_src_offset.s_reg_low) + push_offset, rs_off); 856 // Dalvik register annotation in LoadBaseIndexedDisp() used wrong offset. Fix it. 857 DCHECK(!DECODE_ALIAS_INFO_WIDE(last_lir_insn_->flags.alias_info)); 858 int reg_id = DECODE_ALIAS_INFO_REG(last_lir_insn_->flags.alias_info) - push_offset / 4u; 859 AnnotateDalvikRegAccess(last_lir_insn_, reg_id, true, false); 860 } 861 NewLIR4(kX86LockCmpxchg64A, rs_obj.GetReg(), rs_off.GetReg(), 0, 0); 862 863 // After a store we need to insert barrier in case of potential load. Since the 864 // locked cmpxchg has full barrier semantics, only a scheduling barrier will be generated. 865 GenMemBarrier(kStoreLoad); 866 867 868 if (push_si) { 869 FreeTemp(rs_rSI); 870 UnmarkTemp(rs_rSI); 871 NewLIR1(kX86Pop32R, rs_rSI.GetReg()); 872 } 873 if (push_di) { 874 FreeTemp(rs_rDI); 875 UnmarkTemp(rs_rDI); 876 NewLIR1(kX86Pop32R, rs_rDI.GetReg()); 877 } 878 FreeCallTemps(); 879 } else { 880 // EAX must hold expected for CMPXCHG. Neither rl_new_value, nor r_ptr may be in EAX. 881 FlushReg(rs_r0); 882 Clobber(rs_r0); 883 LockTemp(rs_r0); 884 885 RegLocation rl_object = LoadValue(rl_src_obj, kRefReg); 886 RegLocation rl_new_value = LoadValue(rl_src_new_value); 887 888 if (is_object && !mir_graph_->IsConstantNullRef(rl_new_value)) { 889 // Mark card for object assuming new value is stored. 890 FreeTemp(rs_r0); // Temporarily release EAX for MarkGCCard(). 891 MarkGCCard(rl_new_value.reg, rl_object.reg); 892 LockTemp(rs_r0); 893 } 894 895 RegLocation rl_offset = LoadValue(rl_src_offset, kCoreReg); 896 LoadValueDirect(rl_src_expected, rs_r0); 897 NewLIR5(kX86LockCmpxchgAR, rl_object.reg.GetReg(), rl_offset.reg.GetReg(), 0, 0, rl_new_value.reg.GetReg()); 898 899 // After a store we need to insert barrier in case of potential load. Since the 900 // locked cmpxchg has full barrier semantics, only a scheduling barrier will be generated. 901 GenMemBarrier(kStoreLoad); 902 903 FreeTemp(rs_r0); 904 } 905 906 // Convert ZF to boolean 907 RegLocation rl_dest = InlineTarget(info); // boolean place for result 908 RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); 909 RegStorage result_reg = rl_result.reg; 910 911 // For 32-bit, SETcc only works with EAX..EDX. 912 if (!IsByteRegister(result_reg)) { 913 result_reg = AllocateByteRegister(); 914 } 915 NewLIR2(kX86Set8R, result_reg.GetReg(), kX86CondZ); 916 NewLIR2(kX86Movzx8RR, rl_result.reg.GetReg(), result_reg.GetReg()); 917 if (IsTemp(result_reg)) { 918 FreeTemp(result_reg); 919 } 920 StoreValue(rl_dest, rl_result); 921 return true; 922} 923 924LIR* X86Mir2Lir::OpPcRelLoad(RegStorage reg, LIR* target) { 925 CHECK(base_of_code_ != nullptr); 926 927 // Address the start of the method 928 RegLocation rl_method = mir_graph_->GetRegLocation(base_of_code_->s_reg_low); 929 if (rl_method.wide) { 930 LoadValueDirectWideFixed(rl_method, reg); 931 } else { 932 LoadValueDirectFixed(rl_method, reg); 933 } 934 store_method_addr_used_ = true; 935 936 // Load the proper value from the literal area. 937 // We don't know the proper offset for the value, so pick one that will force 938 // 4 byte offset. We will fix this up in the assembler later to have the right 939 // value. 940 ScopedMemRefType mem_ref_type(this, ResourceMask::kLiteral); 941 LIR *res = RawLIR(current_dalvik_offset_, kX86Mov32RM, reg.GetReg(), reg.GetReg(), 256, 942 0, 0, target); 943 res->target = target; 944 res->flags.fixup = kFixupLoad; 945 store_method_addr_used_ = true; 946 return res; 947} 948 949LIR* X86Mir2Lir::OpVldm(RegStorage r_base, int count) { 950 LOG(FATAL) << "Unexpected use of OpVldm for x86"; 951 return NULL; 952} 953 954LIR* X86Mir2Lir::OpVstm(RegStorage r_base, int count) { 955 LOG(FATAL) << "Unexpected use of OpVstm for x86"; 956 return NULL; 957} 958 959void X86Mir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src, 960 RegLocation rl_result, int lit, 961 int first_bit, int second_bit) { 962 RegStorage t_reg = AllocTemp(); 963 OpRegRegImm(kOpLsl, t_reg, rl_src.reg, second_bit - first_bit); 964 OpRegRegReg(kOpAdd, rl_result.reg, rl_src.reg, t_reg); 965 FreeTemp(t_reg); 966 if (first_bit != 0) { 967 OpRegRegImm(kOpLsl, rl_result.reg, rl_result.reg, first_bit); 968 } 969} 970 971void X86Mir2Lir::GenDivZeroCheckWide(RegStorage reg) { 972 if (Gen64Bit()) { 973 DCHECK(reg.Is64Bit()); 974 975 NewLIR2(kX86Cmp64RI8, reg.GetReg(), 0); 976 } else { 977 DCHECK(reg.IsPair()); 978 979 // We are not supposed to clobber the incoming storage, so allocate a temporary. 980 RegStorage t_reg = AllocTemp(); 981 // Doing an OR is a quick way to check if both registers are zero. This will set the flags. 982 OpRegRegReg(kOpOr, t_reg, reg.GetLow(), reg.GetHigh()); 983 // The temp is no longer needed so free it at this time. 984 FreeTemp(t_reg); 985 } 986 987 // In case of zero, throw ArithmeticException. 988 GenDivZeroCheck(kCondEq); 989} 990 991void X86Mir2Lir::GenArrayBoundsCheck(RegStorage index, 992 RegStorage array_base, 993 int len_offset) { 994 class ArrayBoundsCheckSlowPath : public Mir2Lir::LIRSlowPath { 995 public: 996 ArrayBoundsCheckSlowPath(Mir2Lir* m2l, LIR* branch, 997 RegStorage index, RegStorage array_base, int32_t len_offset) 998 : LIRSlowPath(m2l, m2l->GetCurrentDexPc(), branch), 999 index_(index), array_base_(array_base), len_offset_(len_offset) { 1000 } 1001 1002 void Compile() OVERRIDE { 1003 m2l_->ResetRegPool(); 1004 m2l_->ResetDefTracking(); 1005 GenerateTargetLabel(kPseudoThrowTarget); 1006 1007 RegStorage new_index = index_; 1008 // Move index out of kArg1, either directly to kArg0, or to kArg2. 1009 if (index_.GetReg() == m2l_->TargetReg(kArg1).GetReg()) { 1010 if (array_base_.GetReg() == m2l_->TargetReg(kArg0).GetReg()) { 1011 m2l_->OpRegCopy(m2l_->TargetReg(kArg2), index_); 1012 new_index = m2l_->TargetReg(kArg2); 1013 } else { 1014 m2l_->OpRegCopy(m2l_->TargetReg(kArg0), index_); 1015 new_index = m2l_->TargetReg(kArg0); 1016 } 1017 } 1018 // Load array length to kArg1. 1019 m2l_->OpRegMem(kOpMov, m2l_->TargetReg(kArg1), array_base_, len_offset_); 1020 if (cu_->target64) { 1021 m2l_->CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(8, pThrowArrayBounds), 1022 new_index, m2l_->TargetReg(kArg1), true); 1023 } else { 1024 m2l_->CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(4, pThrowArrayBounds), 1025 new_index, m2l_->TargetReg(kArg1), true); 1026 } 1027 } 1028 1029 private: 1030 const RegStorage index_; 1031 const RegStorage array_base_; 1032 const int32_t len_offset_; 1033 }; 1034 1035 OpRegMem(kOpCmp, index, array_base, len_offset); 1036 LIR* branch = OpCondBranch(kCondUge, nullptr); 1037 AddSlowPath(new (arena_) ArrayBoundsCheckSlowPath(this, branch, 1038 index, array_base, len_offset)); 1039} 1040 1041void X86Mir2Lir::GenArrayBoundsCheck(int32_t index, 1042 RegStorage array_base, 1043 int32_t len_offset) { 1044 class ArrayBoundsCheckSlowPath : public Mir2Lir::LIRSlowPath { 1045 public: 1046 ArrayBoundsCheckSlowPath(Mir2Lir* m2l, LIR* branch, 1047 int32_t index, RegStorage array_base, int32_t len_offset) 1048 : LIRSlowPath(m2l, m2l->GetCurrentDexPc(), branch), 1049 index_(index), array_base_(array_base), len_offset_(len_offset) { 1050 } 1051 1052 void Compile() OVERRIDE { 1053 m2l_->ResetRegPool(); 1054 m2l_->ResetDefTracking(); 1055 GenerateTargetLabel(kPseudoThrowTarget); 1056 1057 // Load array length to kArg1. 1058 m2l_->OpRegMem(kOpMov, m2l_->TargetReg(kArg1), array_base_, len_offset_); 1059 m2l_->LoadConstant(m2l_->TargetReg(kArg0), index_); 1060 if (cu_->target64) { 1061 m2l_->CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(8, pThrowArrayBounds), 1062 m2l_->TargetReg(kArg0), m2l_->TargetReg(kArg1), true); 1063 } else { 1064 m2l_->CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(4, pThrowArrayBounds), 1065 m2l_->TargetReg(kArg0), m2l_->TargetReg(kArg1), true); 1066 } 1067 } 1068 1069 private: 1070 const int32_t index_; 1071 const RegStorage array_base_; 1072 const int32_t len_offset_; 1073 }; 1074 1075 NewLIR3(IS_SIMM8(index) ? kX86Cmp32MI8 : kX86Cmp32MI, array_base.GetReg(), len_offset, index); 1076 LIR* branch = OpCondBranch(kCondLs, nullptr); 1077 AddSlowPath(new (arena_) ArrayBoundsCheckSlowPath(this, branch, 1078 index, array_base, len_offset)); 1079} 1080 1081// Test suspend flag, return target of taken suspend branch 1082LIR* X86Mir2Lir::OpTestSuspend(LIR* target) { 1083 if (cu_->target64) { 1084 OpTlsCmp(Thread::ThreadFlagsOffset<8>(), 0); 1085 } else { 1086 OpTlsCmp(Thread::ThreadFlagsOffset<4>(), 0); 1087 } 1088 return OpCondBranch((target == NULL) ? kCondNe : kCondEq, target); 1089} 1090 1091// Decrement register and branch on condition 1092LIR* X86Mir2Lir::OpDecAndBranch(ConditionCode c_code, RegStorage reg, LIR* target) { 1093 OpRegImm(kOpSub, reg, 1); 1094 return OpCondBranch(c_code, target); 1095} 1096 1097bool X86Mir2Lir::SmallLiteralDivRem(Instruction::Code dalvik_opcode, bool is_div, 1098 RegLocation rl_src, RegLocation rl_dest, int lit) { 1099 LOG(FATAL) << "Unexpected use of smallLiteralDive in x86"; 1100 return false; 1101} 1102 1103bool X86Mir2Lir::EasyMultiply(RegLocation rl_src, RegLocation rl_dest, int lit) { 1104 LOG(FATAL) << "Unexpected use of easyMultiply in x86"; 1105 return false; 1106} 1107 1108LIR* X86Mir2Lir::OpIT(ConditionCode cond, const char* guide) { 1109 LOG(FATAL) << "Unexpected use of OpIT in x86"; 1110 return NULL; 1111} 1112 1113void X86Mir2Lir::OpEndIT(LIR* it) { 1114 LOG(FATAL) << "Unexpected use of OpEndIT in x86"; 1115} 1116 1117void X86Mir2Lir::GenImulRegImm(RegStorage dest, RegStorage src, int val) { 1118 switch (val) { 1119 case 0: 1120 NewLIR2(kX86Xor32RR, dest.GetReg(), dest.GetReg()); 1121 break; 1122 case 1: 1123 OpRegCopy(dest, src); 1124 break; 1125 default: 1126 OpRegRegImm(kOpMul, dest, src, val); 1127 break; 1128 } 1129} 1130 1131void X86Mir2Lir::GenImulMemImm(RegStorage dest, int sreg, int displacement, int val) { 1132 // All memory accesses below reference dalvik regs. 1133 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 1134 1135 LIR *m; 1136 switch (val) { 1137 case 0: 1138 NewLIR2(kX86Xor32RR, dest.GetReg(), dest.GetReg()); 1139 break; 1140 case 1: 1141 LoadBaseDisp(rs_rX86_SP, displacement, dest, k32, kNotVolatile); 1142 break; 1143 default: 1144 m = NewLIR4(IS_SIMM8(val) ? kX86Imul32RMI8 : kX86Imul32RMI, dest.GetReg(), 1145 rs_rX86_SP.GetReg(), displacement, val); 1146 AnnotateDalvikRegAccess(m, displacement >> 2, true /* is_load */, true /* is_64bit */); 1147 break; 1148 } 1149} 1150 1151void X86Mir2Lir::GenMulLong(Instruction::Code, RegLocation rl_dest, RegLocation rl_src1, 1152 RegLocation rl_src2) { 1153 // All memory accesses below reference dalvik regs. 1154 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 1155 1156 if (Gen64Bit()) { 1157 if (rl_src1.is_const) { 1158 std::swap(rl_src1, rl_src2); 1159 } 1160 // Are we multiplying by a constant? 1161 if (rl_src2.is_const) { 1162 int64_t val = mir_graph_->ConstantValueWide(rl_src2); 1163 if (val == 0) { 1164 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1165 OpRegReg(kOpXor, rl_result.reg, rl_result.reg); 1166 StoreValueWide(rl_dest, rl_result); 1167 return; 1168 } else if (val == 1) { 1169 StoreValueWide(rl_dest, rl_src1); 1170 return; 1171 } else if (val == 2) { 1172 GenAddLong(Instruction::ADD_LONG, rl_dest, rl_src1, rl_src1); 1173 return; 1174 } else if (IsPowerOfTwo(val)) { 1175 int shift_amount = LowestSetBit(val); 1176 if (!BadOverlap(rl_src1, rl_dest)) { 1177 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 1178 RegLocation rl_result = GenShiftImmOpLong(Instruction::SHL_LONG, rl_dest, 1179 rl_src1, shift_amount); 1180 StoreValueWide(rl_dest, rl_result); 1181 return; 1182 } 1183 } 1184 } 1185 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 1186 rl_src2 = LoadValueWide(rl_src2, kCoreReg); 1187 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1188 if (rl_result.reg.GetReg() == rl_src1.reg.GetReg() && 1189 rl_result.reg.GetReg() == rl_src2.reg.GetReg()) { 1190 NewLIR2(kX86Imul64RR, rl_result.reg.GetReg(), rl_result.reg.GetReg()); 1191 } else if (rl_result.reg.GetReg() != rl_src1.reg.GetReg() && 1192 rl_result.reg.GetReg() == rl_src2.reg.GetReg()) { 1193 NewLIR2(kX86Imul64RR, rl_result.reg.GetReg(), rl_src1.reg.GetReg()); 1194 } else if (rl_result.reg.GetReg() == rl_src1.reg.GetReg() && 1195 rl_result.reg.GetReg() != rl_src2.reg.GetReg()) { 1196 NewLIR2(kX86Imul64RR, rl_result.reg.GetReg(), rl_src2.reg.GetReg()); 1197 } else { 1198 OpRegCopy(rl_result.reg, rl_src1.reg); 1199 NewLIR2(kX86Imul64RR, rl_result.reg.GetReg(), rl_src2.reg.GetReg()); 1200 } 1201 StoreValueWide(rl_dest, rl_result); 1202 return; 1203 } 1204 1205 if (rl_src1.is_const) { 1206 std::swap(rl_src1, rl_src2); 1207 } 1208 // Are we multiplying by a constant? 1209 if (rl_src2.is_const) { 1210 // Do special compare/branch against simple const operand 1211 int64_t val = mir_graph_->ConstantValueWide(rl_src2); 1212 if (val == 0) { 1213 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1214 OpRegReg(kOpXor, rl_result.reg.GetLow(), rl_result.reg.GetLow()); 1215 OpRegReg(kOpXor, rl_result.reg.GetHigh(), rl_result.reg.GetHigh()); 1216 StoreValueWide(rl_dest, rl_result); 1217 return; 1218 } else if (val == 1) { 1219 StoreValueWide(rl_dest, rl_src1); 1220 return; 1221 } else if (val == 2) { 1222 GenAddLong(Instruction::ADD_LONG, rl_dest, rl_src1, rl_src1); 1223 return; 1224 } else if (IsPowerOfTwo(val)) { 1225 int shift_amount = LowestSetBit(val); 1226 if (!BadOverlap(rl_src1, rl_dest)) { 1227 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 1228 RegLocation rl_result = GenShiftImmOpLong(Instruction::SHL_LONG, rl_dest, 1229 rl_src1, shift_amount); 1230 StoreValueWide(rl_dest, rl_result); 1231 return; 1232 } 1233 } 1234 1235 // Okay, just bite the bullet and do it. 1236 int32_t val_lo = Low32Bits(val); 1237 int32_t val_hi = High32Bits(val); 1238 FlushAllRegs(); 1239 LockCallTemps(); // Prepare for explicit register usage. 1240 rl_src1 = UpdateLocWideTyped(rl_src1, kCoreReg); 1241 bool src1_in_reg = rl_src1.location == kLocPhysReg; 1242 int displacement = SRegOffset(rl_src1.s_reg_low); 1243 1244 // ECX <- 1H * 2L 1245 // EAX <- 1L * 2H 1246 if (src1_in_reg) { 1247 GenImulRegImm(rs_r1, rl_src1.reg.GetHigh(), val_lo); 1248 GenImulRegImm(rs_r0, rl_src1.reg.GetLow(), val_hi); 1249 } else { 1250 GenImulMemImm(rs_r1, GetSRegHi(rl_src1.s_reg_low), displacement + HIWORD_OFFSET, val_lo); 1251 GenImulMemImm(rs_r0, rl_src1.s_reg_low, displacement + LOWORD_OFFSET, val_hi); 1252 } 1253 1254 // ECX <- ECX + EAX (2H * 1L) + (1H * 2L) 1255 NewLIR2(kX86Add32RR, rs_r1.GetReg(), rs_r0.GetReg()); 1256 1257 // EAX <- 2L 1258 LoadConstantNoClobber(rs_r0, val_lo); 1259 1260 // EDX:EAX <- 2L * 1L (double precision) 1261 if (src1_in_reg) { 1262 NewLIR1(kX86Mul32DaR, rl_src1.reg.GetLowReg()); 1263 } else { 1264 LIR *m = NewLIR2(kX86Mul32DaM, rs_rX86_SP.GetReg(), displacement + LOWORD_OFFSET); 1265 AnnotateDalvikRegAccess(m, (displacement + LOWORD_OFFSET) >> 2, 1266 true /* is_load */, true /* is_64bit */); 1267 } 1268 1269 // EDX <- EDX + ECX (add high words) 1270 NewLIR2(kX86Add32RR, rs_r2.GetReg(), rs_r1.GetReg()); 1271 1272 // Result is EDX:EAX 1273 RegLocation rl_result = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, 1274 RegStorage::MakeRegPair(rs_r0, rs_r2), INVALID_SREG, INVALID_SREG}; 1275 StoreValueWide(rl_dest, rl_result); 1276 return; 1277 } 1278 1279 // Nope. Do it the hard way 1280 // Check for V*V. We can eliminate a multiply in that case, as 2L*1H == 2H*1L. 1281 bool is_square = mir_graph_->SRegToVReg(rl_src1.s_reg_low) == 1282 mir_graph_->SRegToVReg(rl_src2.s_reg_low); 1283 1284 FlushAllRegs(); 1285 LockCallTemps(); // Prepare for explicit register usage. 1286 rl_src1 = UpdateLocWideTyped(rl_src1, kCoreReg); 1287 rl_src2 = UpdateLocWideTyped(rl_src2, kCoreReg); 1288 1289 // At this point, the VRs are in their home locations. 1290 bool src1_in_reg = rl_src1.location == kLocPhysReg; 1291 bool src2_in_reg = rl_src2.location == kLocPhysReg; 1292 1293 // ECX <- 1H 1294 if (src1_in_reg) { 1295 NewLIR2(kX86Mov32RR, rs_r1.GetReg(), rl_src1.reg.GetHighReg()); 1296 } else { 1297 LoadBaseDisp(rs_rX86_SP, SRegOffset(rl_src1.s_reg_low) + HIWORD_OFFSET, rs_r1, k32, 1298 kNotVolatile); 1299 } 1300 1301 if (is_square) { 1302 // Take advantage of the fact that the values are the same. 1303 // ECX <- ECX * 2L (1H * 2L) 1304 if (src2_in_reg) { 1305 NewLIR2(kX86Imul32RR, rs_r1.GetReg(), rl_src2.reg.GetLowReg()); 1306 } else { 1307 int displacement = SRegOffset(rl_src2.s_reg_low); 1308 LIR *m = NewLIR3(kX86Imul32RM, rs_r1.GetReg(), rs_rX86_SP.GetReg(), 1309 displacement + LOWORD_OFFSET); 1310 AnnotateDalvikRegAccess(m, (displacement + LOWORD_OFFSET) >> 2, 1311 true /* is_load */, true /* is_64bit */); 1312 } 1313 1314 // ECX <- 2*ECX (2H * 1L) + (1H * 2L) 1315 NewLIR2(kX86Add32RR, rs_r1.GetReg(), rs_r1.GetReg()); 1316 } else { 1317 // EAX <- 2H 1318 if (src2_in_reg) { 1319 NewLIR2(kX86Mov32RR, rs_r0.GetReg(), rl_src2.reg.GetHighReg()); 1320 } else { 1321 LoadBaseDisp(rs_rX86_SP, SRegOffset(rl_src2.s_reg_low) + HIWORD_OFFSET, rs_r0, k32, 1322 kNotVolatile); 1323 } 1324 1325 // EAX <- EAX * 1L (2H * 1L) 1326 if (src1_in_reg) { 1327 NewLIR2(kX86Imul32RR, rs_r0.GetReg(), rl_src1.reg.GetLowReg()); 1328 } else { 1329 int displacement = SRegOffset(rl_src1.s_reg_low); 1330 LIR *m = NewLIR3(kX86Imul32RM, rs_r0.GetReg(), rs_rX86_SP.GetReg(), 1331 displacement + LOWORD_OFFSET); 1332 AnnotateDalvikRegAccess(m, (displacement + LOWORD_OFFSET) >> 2, 1333 true /* is_load */, true /* is_64bit */); 1334 } 1335 1336 // ECX <- ECX * 2L (1H * 2L) 1337 if (src2_in_reg) { 1338 NewLIR2(kX86Imul32RR, rs_r1.GetReg(), rl_src2.reg.GetLowReg()); 1339 } else { 1340 int displacement = SRegOffset(rl_src2.s_reg_low); 1341 LIR *m = NewLIR3(kX86Imul32RM, rs_r1.GetReg(), rs_rX86_SP.GetReg(), 1342 displacement + LOWORD_OFFSET); 1343 AnnotateDalvikRegAccess(m, (displacement + LOWORD_OFFSET) >> 2, 1344 true /* is_load */, true /* is_64bit */); 1345 } 1346 1347 // ECX <- ECX + EAX (2H * 1L) + (1H * 2L) 1348 NewLIR2(kX86Add32RR, rs_r1.GetReg(), rs_r0.GetReg()); 1349 } 1350 1351 // EAX <- 2L 1352 if (src2_in_reg) { 1353 NewLIR2(kX86Mov32RR, rs_r0.GetReg(), rl_src2.reg.GetLowReg()); 1354 } else { 1355 LoadBaseDisp(rs_rX86_SP, SRegOffset(rl_src2.s_reg_low) + LOWORD_OFFSET, rs_r0, k32, 1356 kNotVolatile); 1357 } 1358 1359 // EDX:EAX <- 2L * 1L (double precision) 1360 if (src1_in_reg) { 1361 NewLIR1(kX86Mul32DaR, rl_src1.reg.GetLowReg()); 1362 } else { 1363 int displacement = SRegOffset(rl_src1.s_reg_low); 1364 LIR *m = NewLIR2(kX86Mul32DaM, rs_rX86_SP.GetReg(), displacement + LOWORD_OFFSET); 1365 AnnotateDalvikRegAccess(m, (displacement + LOWORD_OFFSET) >> 2, 1366 true /* is_load */, true /* is_64bit */); 1367 } 1368 1369 // EDX <- EDX + ECX (add high words) 1370 NewLIR2(kX86Add32RR, rs_r2.GetReg(), rs_r1.GetReg()); 1371 1372 // Result is EDX:EAX 1373 RegLocation rl_result = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, 1374 RegStorage::MakeRegPair(rs_r0, rs_r2), INVALID_SREG, INVALID_SREG}; 1375 StoreValueWide(rl_dest, rl_result); 1376} 1377 1378void X86Mir2Lir::GenLongRegOrMemOp(RegLocation rl_dest, RegLocation rl_src, 1379 Instruction::Code op) { 1380 DCHECK_EQ(rl_dest.location, kLocPhysReg); 1381 X86OpCode x86op = GetOpcode(op, rl_dest, rl_src, false); 1382 if (rl_src.location == kLocPhysReg) { 1383 // Both operands are in registers. 1384 // But we must ensure that rl_src is in pair 1385 if (Gen64Bit()) { 1386 NewLIR2(x86op, rl_dest.reg.GetReg(), rl_src.reg.GetReg()); 1387 } else { 1388 rl_src = LoadValueWide(rl_src, kCoreReg); 1389 if (rl_dest.reg.GetLowReg() == rl_src.reg.GetHighReg()) { 1390 // The registers are the same, so we would clobber it before the use. 1391 RegStorage temp_reg = AllocTemp(); 1392 OpRegCopy(temp_reg, rl_dest.reg); 1393 rl_src.reg.SetHighReg(temp_reg.GetReg()); 1394 } 1395 NewLIR2(x86op, rl_dest.reg.GetLowReg(), rl_src.reg.GetLowReg()); 1396 1397 x86op = GetOpcode(op, rl_dest, rl_src, true); 1398 NewLIR2(x86op, rl_dest.reg.GetHighReg(), rl_src.reg.GetHighReg()); 1399 FreeTemp(rl_src.reg); // ??? 1400 } 1401 return; 1402 } 1403 1404 // RHS is in memory. 1405 DCHECK((rl_src.location == kLocDalvikFrame) || 1406 (rl_src.location == kLocCompilerTemp)); 1407 int r_base = TargetReg(kSp).GetReg(); 1408 int displacement = SRegOffset(rl_src.s_reg_low); 1409 1410 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 1411 LIR *lir = NewLIR3(x86op, Gen64Bit() ? rl_dest.reg.GetReg() : rl_dest.reg.GetLowReg(), r_base, displacement + LOWORD_OFFSET); 1412 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 1413 true /* is_load */, true /* is64bit */); 1414 if (!Gen64Bit()) { 1415 x86op = GetOpcode(op, rl_dest, rl_src, true); 1416 lir = NewLIR3(x86op, rl_dest.reg.GetHighReg(), r_base, displacement + HIWORD_OFFSET); 1417 AnnotateDalvikRegAccess(lir, (displacement + HIWORD_OFFSET) >> 2, 1418 true /* is_load */, true /* is64bit */); 1419 } 1420} 1421 1422void X86Mir2Lir::GenLongArith(RegLocation rl_dest, RegLocation rl_src, Instruction::Code op) { 1423 rl_dest = UpdateLocWideTyped(rl_dest, kCoreReg); 1424 if (rl_dest.location == kLocPhysReg) { 1425 // Ensure we are in a register pair 1426 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1427 1428 rl_src = UpdateLocWideTyped(rl_src, kCoreReg); 1429 GenLongRegOrMemOp(rl_result, rl_src, op); 1430 StoreFinalValueWide(rl_dest, rl_result); 1431 return; 1432 } 1433 1434 // It wasn't in registers, so it better be in memory. 1435 DCHECK((rl_dest.location == kLocDalvikFrame) || 1436 (rl_dest.location == kLocCompilerTemp)); 1437 rl_src = LoadValueWide(rl_src, kCoreReg); 1438 1439 // Operate directly into memory. 1440 X86OpCode x86op = GetOpcode(op, rl_dest, rl_src, false); 1441 int r_base = TargetReg(kSp).GetReg(); 1442 int displacement = SRegOffset(rl_dest.s_reg_low); 1443 1444 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 1445 LIR *lir = NewLIR3(x86op, r_base, displacement + LOWORD_OFFSET, 1446 Gen64Bit() ? rl_src.reg.GetReg() : rl_src.reg.GetLowReg()); 1447 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 1448 true /* is_load */, true /* is64bit */); 1449 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 1450 false /* is_load */, true /* is64bit */); 1451 if (!Gen64Bit()) { 1452 x86op = GetOpcode(op, rl_dest, rl_src, true); 1453 lir = NewLIR3(x86op, r_base, displacement + HIWORD_OFFSET, rl_src.reg.GetHighReg()); 1454 AnnotateDalvikRegAccess(lir, (displacement + HIWORD_OFFSET) >> 2, 1455 true /* is_load */, true /* is64bit */); 1456 AnnotateDalvikRegAccess(lir, (displacement + HIWORD_OFFSET) >> 2, 1457 false /* is_load */, true /* is64bit */); 1458 } 1459 FreeTemp(rl_src.reg); 1460} 1461 1462void X86Mir2Lir::GenLongArith(RegLocation rl_dest, RegLocation rl_src1, 1463 RegLocation rl_src2, Instruction::Code op, 1464 bool is_commutative) { 1465 // Is this really a 2 operand operation? 1466 switch (op) { 1467 case Instruction::ADD_LONG_2ADDR: 1468 case Instruction::SUB_LONG_2ADDR: 1469 case Instruction::AND_LONG_2ADDR: 1470 case Instruction::OR_LONG_2ADDR: 1471 case Instruction::XOR_LONG_2ADDR: 1472 if (GenerateTwoOperandInstructions()) { 1473 GenLongArith(rl_dest, rl_src2, op); 1474 return; 1475 } 1476 break; 1477 1478 default: 1479 break; 1480 } 1481 1482 if (rl_dest.location == kLocPhysReg) { 1483 RegLocation rl_result = LoadValueWide(rl_src1, kCoreReg); 1484 1485 // We are about to clobber the LHS, so it needs to be a temp. 1486 rl_result = ForceTempWide(rl_result); 1487 1488 // Perform the operation using the RHS. 1489 rl_src2 = UpdateLocWideTyped(rl_src2, kCoreReg); 1490 GenLongRegOrMemOp(rl_result, rl_src2, op); 1491 1492 // And now record that the result is in the temp. 1493 StoreFinalValueWide(rl_dest, rl_result); 1494 return; 1495 } 1496 1497 // It wasn't in registers, so it better be in memory. 1498 DCHECK((rl_dest.location == kLocDalvikFrame) || 1499 (rl_dest.location == kLocCompilerTemp)); 1500 rl_src1 = UpdateLocWideTyped(rl_src1, kCoreReg); 1501 rl_src2 = UpdateLocWideTyped(rl_src2, kCoreReg); 1502 1503 // Get one of the source operands into temporary register. 1504 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 1505 if (Gen64Bit()) { 1506 if (IsTemp(rl_src1.reg)) { 1507 GenLongRegOrMemOp(rl_src1, rl_src2, op); 1508 } else if (is_commutative) { 1509 rl_src2 = LoadValueWide(rl_src2, kCoreReg); 1510 // We need at least one of them to be a temporary. 1511 if (!IsTemp(rl_src2.reg)) { 1512 rl_src1 = ForceTempWide(rl_src1); 1513 GenLongRegOrMemOp(rl_src1, rl_src2, op); 1514 } else { 1515 GenLongRegOrMemOp(rl_src2, rl_src1, op); 1516 StoreFinalValueWide(rl_dest, rl_src2); 1517 return; 1518 } 1519 } else { 1520 // Need LHS to be the temp. 1521 rl_src1 = ForceTempWide(rl_src1); 1522 GenLongRegOrMemOp(rl_src1, rl_src2, op); 1523 } 1524 } else { 1525 if (IsTemp(rl_src1.reg.GetLow()) && IsTemp(rl_src1.reg.GetHigh())) { 1526 GenLongRegOrMemOp(rl_src1, rl_src2, op); 1527 } else if (is_commutative) { 1528 rl_src2 = LoadValueWide(rl_src2, kCoreReg); 1529 // We need at least one of them to be a temporary. 1530 if (!(IsTemp(rl_src2.reg.GetLow()) && IsTemp(rl_src2.reg.GetHigh()))) { 1531 rl_src1 = ForceTempWide(rl_src1); 1532 GenLongRegOrMemOp(rl_src1, rl_src2, op); 1533 } else { 1534 GenLongRegOrMemOp(rl_src2, rl_src1, op); 1535 StoreFinalValueWide(rl_dest, rl_src2); 1536 return; 1537 } 1538 } else { 1539 // Need LHS to be the temp. 1540 rl_src1 = ForceTempWide(rl_src1); 1541 GenLongRegOrMemOp(rl_src1, rl_src2, op); 1542 } 1543 } 1544 1545 StoreFinalValueWide(rl_dest, rl_src1); 1546} 1547 1548void X86Mir2Lir::GenAddLong(Instruction::Code opcode, RegLocation rl_dest, 1549 RegLocation rl_src1, RegLocation rl_src2) { 1550 GenLongArith(rl_dest, rl_src1, rl_src2, opcode, true); 1551} 1552 1553void X86Mir2Lir::GenSubLong(Instruction::Code opcode, RegLocation rl_dest, 1554 RegLocation rl_src1, RegLocation rl_src2) { 1555 GenLongArith(rl_dest, rl_src1, rl_src2, opcode, false); 1556} 1557 1558void X86Mir2Lir::GenAndLong(Instruction::Code opcode, RegLocation rl_dest, 1559 RegLocation rl_src1, RegLocation rl_src2) { 1560 GenLongArith(rl_dest, rl_src1, rl_src2, opcode, true); 1561} 1562 1563void X86Mir2Lir::GenOrLong(Instruction::Code opcode, RegLocation rl_dest, 1564 RegLocation rl_src1, RegLocation rl_src2) { 1565 GenLongArith(rl_dest, rl_src1, rl_src2, opcode, true); 1566} 1567 1568void X86Mir2Lir::GenXorLong(Instruction::Code opcode, RegLocation rl_dest, 1569 RegLocation rl_src1, RegLocation rl_src2) { 1570 GenLongArith(rl_dest, rl_src1, rl_src2, opcode, true); 1571} 1572 1573void X86Mir2Lir::GenNotLong(RegLocation rl_dest, RegLocation rl_src) { 1574 if (Gen64Bit()) { 1575 rl_src = LoadValueWide(rl_src, kCoreReg); 1576 RegLocation rl_result; 1577 rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1578 OpRegCopy(rl_result.reg, rl_src.reg); 1579 OpReg(kOpNot, rl_result.reg); 1580 StoreValueWide(rl_dest, rl_result); 1581 } else { 1582 LOG(FATAL) << "Unexpected use GenNotLong()"; 1583 } 1584} 1585 1586void X86Mir2Lir::GenDivRemLong(Instruction::Code, RegLocation rl_dest, RegLocation rl_src1, 1587 RegLocation rl_src2, bool is_div) { 1588 if (!Gen64Bit()) { 1589 LOG(FATAL) << "Unexpected use GenDivRemLong()"; 1590 return; 1591 } 1592 1593 // We have to use fixed registers, so flush all the temps. 1594 FlushAllRegs(); 1595 LockCallTemps(); // Prepare for explicit register usage. 1596 1597 // Load LHS into RAX. 1598 LoadValueDirectWideFixed(rl_src1, rs_r0q); 1599 1600 // Load RHS into RCX. 1601 LoadValueDirectWideFixed(rl_src2, rs_r1q); 1602 1603 // Copy LHS sign bit into RDX. 1604 NewLIR0(kx86Cqo64Da); 1605 1606 // Handle division by zero case. 1607 GenDivZeroCheckWide(rs_r1q); 1608 1609 // Have to catch 0x8000000000000000/-1 case, or we will get an exception! 1610 NewLIR2(kX86Cmp64RI8, rs_r1q.GetReg(), -1); 1611 LIR *minus_one_branch = NewLIR2(kX86Jcc8, 0, kX86CondNe); 1612 1613 // RHS is -1. 1614 LoadConstantWide(rs_r6q, 0x8000000000000000); 1615 NewLIR2(kX86Cmp64RR, rs_r0q.GetReg(), rs_r6q.GetReg()); 1616 LIR * minint_branch = NewLIR2(kX86Jcc8, 0, kX86CondNe); 1617 1618 // In 0x8000000000000000/-1 case. 1619 if (!is_div) { 1620 // For DIV, RAX is already right. For REM, we need RDX 0. 1621 NewLIR2(kX86Xor64RR, rs_r2q.GetReg(), rs_r2q.GetReg()); 1622 } 1623 LIR* done = NewLIR1(kX86Jmp8, 0); 1624 1625 // Expected case. 1626 minus_one_branch->target = NewLIR0(kPseudoTargetLabel); 1627 minint_branch->target = minus_one_branch->target; 1628 NewLIR1(kX86Idivmod64DaR, rs_r1q.GetReg()); 1629 done->target = NewLIR0(kPseudoTargetLabel); 1630 1631 // Result is in RAX for div and RDX for rem. 1632 RegLocation rl_result = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, rs_r0q, INVALID_SREG, INVALID_SREG}; 1633 if (!is_div) { 1634 rl_result.reg.SetReg(r2q); 1635 } 1636 1637 StoreValueWide(rl_dest, rl_result); 1638} 1639 1640void X86Mir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src) { 1641 rl_src = LoadValueWide(rl_src, kCoreReg); 1642 RegLocation rl_result; 1643 if (Gen64Bit()) { 1644 rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1645 OpRegReg(kOpNeg, rl_result.reg, rl_src.reg); 1646 } else { 1647 rl_result = ForceTempWide(rl_src); 1648 if (((rl_dest.location == kLocPhysReg) && (rl_src.location == kLocPhysReg)) && 1649 ((rl_dest.reg.GetLowReg() == rl_src.reg.GetHighReg()))) { 1650 // The registers are the same, so we would clobber it before the use. 1651 RegStorage temp_reg = AllocTemp(); 1652 OpRegCopy(temp_reg, rl_result.reg); 1653 rl_result.reg.SetHighReg(temp_reg.GetReg()); 1654 } 1655 OpRegReg(kOpNeg, rl_result.reg.GetLow(), rl_result.reg.GetLow()); // rLow = -rLow 1656 OpRegImm(kOpAdc, rl_result.reg.GetHigh(), 0); // rHigh = rHigh + CF 1657 OpRegReg(kOpNeg, rl_result.reg.GetHigh(), rl_result.reg.GetHigh()); // rHigh = -rHigh 1658 } 1659 StoreValueWide(rl_dest, rl_result); 1660} 1661 1662void X86Mir2Lir::OpRegThreadMem(OpKind op, RegStorage r_dest, ThreadOffset<4> thread_offset) { 1663 DCHECK_EQ(kX86, cu_->instruction_set); 1664 X86OpCode opcode = kX86Bkpt; 1665 switch (op) { 1666 case kOpCmp: opcode = kX86Cmp32RT; break; 1667 case kOpMov: opcode = kX86Mov32RT; break; 1668 default: 1669 LOG(FATAL) << "Bad opcode: " << op; 1670 break; 1671 } 1672 NewLIR2(opcode, r_dest.GetReg(), thread_offset.Int32Value()); 1673} 1674 1675void X86Mir2Lir::OpRegThreadMem(OpKind op, RegStorage r_dest, ThreadOffset<8> thread_offset) { 1676 DCHECK_EQ(kX86_64, cu_->instruction_set); 1677 X86OpCode opcode = kX86Bkpt; 1678 if (Gen64Bit() && r_dest.Is64BitSolo()) { 1679 switch (op) { 1680 case kOpCmp: opcode = kX86Cmp64RT; break; 1681 case kOpMov: opcode = kX86Mov64RT; break; 1682 default: 1683 LOG(FATAL) << "Bad opcode(OpRegThreadMem 64): " << op; 1684 break; 1685 } 1686 } else { 1687 switch (op) { 1688 case kOpCmp: opcode = kX86Cmp32RT; break; 1689 case kOpMov: opcode = kX86Mov32RT; break; 1690 default: 1691 LOG(FATAL) << "Bad opcode: " << op; 1692 break; 1693 } 1694 } 1695 NewLIR2(opcode, r_dest.GetReg(), thread_offset.Int32Value()); 1696} 1697 1698/* 1699 * Generate array load 1700 */ 1701void X86Mir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array, 1702 RegLocation rl_index, RegLocation rl_dest, int scale) { 1703 RegisterClass reg_class = RegClassBySize(size); 1704 int len_offset = mirror::Array::LengthOffset().Int32Value(); 1705 RegLocation rl_result; 1706 rl_array = LoadValue(rl_array, kRefReg); 1707 1708 int data_offset; 1709 if (size == k64 || size == kDouble) { 1710 data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value(); 1711 } else { 1712 data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value(); 1713 } 1714 1715 bool constant_index = rl_index.is_const; 1716 int32_t constant_index_value = 0; 1717 if (!constant_index) { 1718 rl_index = LoadValue(rl_index, kCoreReg); 1719 } else { 1720 constant_index_value = mir_graph_->ConstantValue(rl_index); 1721 // If index is constant, just fold it into the data offset 1722 data_offset += constant_index_value << scale; 1723 // treat as non array below 1724 rl_index.reg = RegStorage::InvalidReg(); 1725 } 1726 1727 /* null object? */ 1728 GenNullCheck(rl_array.reg, opt_flags); 1729 1730 if (!(opt_flags & MIR_IGNORE_RANGE_CHECK)) { 1731 if (constant_index) { 1732 GenArrayBoundsCheck(constant_index_value, rl_array.reg, len_offset); 1733 } else { 1734 GenArrayBoundsCheck(rl_index.reg, rl_array.reg, len_offset); 1735 } 1736 } 1737 rl_result = EvalLoc(rl_dest, reg_class, true); 1738 LoadBaseIndexedDisp(rl_array.reg, rl_index.reg, scale, data_offset, rl_result.reg, size); 1739 if ((size == k64) || (size == kDouble)) { 1740 StoreValueWide(rl_dest, rl_result); 1741 } else { 1742 StoreValue(rl_dest, rl_result); 1743 } 1744} 1745 1746/* 1747 * Generate array store 1748 * 1749 */ 1750void X86Mir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array, 1751 RegLocation rl_index, RegLocation rl_src, int scale, bool card_mark) { 1752 RegisterClass reg_class = RegClassBySize(size); 1753 int len_offset = mirror::Array::LengthOffset().Int32Value(); 1754 int data_offset; 1755 1756 if (size == k64 || size == kDouble) { 1757 data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value(); 1758 } else { 1759 data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value(); 1760 } 1761 1762 rl_array = LoadValue(rl_array, kRefReg); 1763 bool constant_index = rl_index.is_const; 1764 int32_t constant_index_value = 0; 1765 if (!constant_index) { 1766 rl_index = LoadValue(rl_index, kCoreReg); 1767 } else { 1768 // If index is constant, just fold it into the data offset 1769 constant_index_value = mir_graph_->ConstantValue(rl_index); 1770 data_offset += constant_index_value << scale; 1771 // treat as non array below 1772 rl_index.reg = RegStorage::InvalidReg(); 1773 } 1774 1775 /* null object? */ 1776 GenNullCheck(rl_array.reg, opt_flags); 1777 1778 if (!(opt_flags & MIR_IGNORE_RANGE_CHECK)) { 1779 if (constant_index) { 1780 GenArrayBoundsCheck(constant_index_value, rl_array.reg, len_offset); 1781 } else { 1782 GenArrayBoundsCheck(rl_index.reg, rl_array.reg, len_offset); 1783 } 1784 } 1785 if ((size == k64) || (size == kDouble)) { 1786 rl_src = LoadValueWide(rl_src, reg_class); 1787 } else { 1788 rl_src = LoadValue(rl_src, reg_class); 1789 } 1790 // If the src reg can't be byte accessed, move it to a temp first. 1791 if ((size == kSignedByte || size == kUnsignedByte) && !IsByteRegister(rl_src.reg)) { 1792 RegStorage temp = AllocTemp(); 1793 OpRegCopy(temp, rl_src.reg); 1794 StoreBaseIndexedDisp(rl_array.reg, rl_index.reg, scale, data_offset, temp, size); 1795 } else { 1796 StoreBaseIndexedDisp(rl_array.reg, rl_index.reg, scale, data_offset, rl_src.reg, size); 1797 } 1798 if (card_mark) { 1799 // Free rl_index if its a temp. Ensures there are 2 free regs for card mark. 1800 if (!constant_index) { 1801 FreeTemp(rl_index.reg); 1802 } 1803 MarkGCCard(rl_src.reg, rl_array.reg); 1804 } 1805} 1806 1807RegLocation X86Mir2Lir::GenShiftImmOpLong(Instruction::Code opcode, RegLocation rl_dest, 1808 RegLocation rl_src, int shift_amount) { 1809 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 1810 if (Gen64Bit()) { 1811 OpKind op = static_cast<OpKind>(0); /* Make gcc happy */ 1812 switch (opcode) { 1813 case Instruction::SHL_LONG: 1814 case Instruction::SHL_LONG_2ADDR: 1815 op = kOpLsl; 1816 break; 1817 case Instruction::SHR_LONG: 1818 case Instruction::SHR_LONG_2ADDR: 1819 op = kOpAsr; 1820 break; 1821 case Instruction::USHR_LONG: 1822 case Instruction::USHR_LONG_2ADDR: 1823 op = kOpLsr; 1824 break; 1825 default: 1826 LOG(FATAL) << "Unexpected case"; 1827 } 1828 OpRegRegImm(op, rl_result.reg, rl_src.reg, shift_amount); 1829 } else { 1830 switch (opcode) { 1831 case Instruction::SHL_LONG: 1832 case Instruction::SHL_LONG_2ADDR: 1833 DCHECK_NE(shift_amount, 1); // Prevent a double store from happening. 1834 if (shift_amount == 32) { 1835 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetLow()); 1836 LoadConstant(rl_result.reg.GetLow(), 0); 1837 } else if (shift_amount > 31) { 1838 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetLow()); 1839 NewLIR2(kX86Sal32RI, rl_result.reg.GetHighReg(), shift_amount - 32); 1840 LoadConstant(rl_result.reg.GetLow(), 0); 1841 } else { 1842 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetLow()); 1843 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetHigh()); 1844 NewLIR3(kX86Shld32RRI, rl_result.reg.GetHighReg(), rl_result.reg.GetLowReg(), 1845 shift_amount); 1846 NewLIR2(kX86Sal32RI, rl_result.reg.GetLowReg(), shift_amount); 1847 } 1848 break; 1849 case Instruction::SHR_LONG: 1850 case Instruction::SHR_LONG_2ADDR: 1851 if (shift_amount == 32) { 1852 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetHigh()); 1853 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetHigh()); 1854 NewLIR2(kX86Sar32RI, rl_result.reg.GetHighReg(), 31); 1855 } else if (shift_amount > 31) { 1856 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetHigh()); 1857 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetHigh()); 1858 NewLIR2(kX86Sar32RI, rl_result.reg.GetLowReg(), shift_amount - 32); 1859 NewLIR2(kX86Sar32RI, rl_result.reg.GetHighReg(), 31); 1860 } else { 1861 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetLow()); 1862 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetHigh()); 1863 NewLIR3(kX86Shrd32RRI, rl_result.reg.GetLowReg(), rl_result.reg.GetHighReg(), 1864 shift_amount); 1865 NewLIR2(kX86Sar32RI, rl_result.reg.GetHighReg(), shift_amount); 1866 } 1867 break; 1868 case Instruction::USHR_LONG: 1869 case Instruction::USHR_LONG_2ADDR: 1870 if (shift_amount == 32) { 1871 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetHigh()); 1872 LoadConstant(rl_result.reg.GetHigh(), 0); 1873 } else if (shift_amount > 31) { 1874 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetHigh()); 1875 NewLIR2(kX86Shr32RI, rl_result.reg.GetLowReg(), shift_amount - 32); 1876 LoadConstant(rl_result.reg.GetHigh(), 0); 1877 } else { 1878 OpRegCopy(rl_result.reg.GetLow(), rl_src.reg.GetLow()); 1879 OpRegCopy(rl_result.reg.GetHigh(), rl_src.reg.GetHigh()); 1880 NewLIR3(kX86Shrd32RRI, rl_result.reg.GetLowReg(), rl_result.reg.GetHighReg(), 1881 shift_amount); 1882 NewLIR2(kX86Shr32RI, rl_result.reg.GetHighReg(), shift_amount); 1883 } 1884 break; 1885 default: 1886 LOG(FATAL) << "Unexpected case"; 1887 } 1888 } 1889 return rl_result; 1890} 1891 1892void X86Mir2Lir::GenShiftImmOpLong(Instruction::Code opcode, RegLocation rl_dest, 1893 RegLocation rl_src, RegLocation rl_shift) { 1894 // Per spec, we only care about low 6 bits of shift amount. 1895 int shift_amount = mir_graph_->ConstantValue(rl_shift) & 0x3f; 1896 if (shift_amount == 0) { 1897 rl_src = LoadValueWide(rl_src, kCoreReg); 1898 StoreValueWide(rl_dest, rl_src); 1899 return; 1900 } else if (shift_amount == 1 && 1901 (opcode == Instruction::SHL_LONG || opcode == Instruction::SHL_LONG_2ADDR)) { 1902 // Need to handle this here to avoid calling StoreValueWide twice. 1903 GenAddLong(Instruction::ADD_LONG, rl_dest, rl_src, rl_src); 1904 return; 1905 } 1906 if (BadOverlap(rl_src, rl_dest)) { 1907 GenShiftOpLong(opcode, rl_dest, rl_src, rl_shift); 1908 return; 1909 } 1910 rl_src = LoadValueWide(rl_src, kCoreReg); 1911 RegLocation rl_result = GenShiftImmOpLong(opcode, rl_dest, rl_src, shift_amount); 1912 StoreValueWide(rl_dest, rl_result); 1913} 1914 1915void X86Mir2Lir::GenArithImmOpLong(Instruction::Code opcode, 1916 RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) { 1917 bool isConstSuccess = false; 1918 switch (opcode) { 1919 case Instruction::ADD_LONG: 1920 case Instruction::AND_LONG: 1921 case Instruction::OR_LONG: 1922 case Instruction::XOR_LONG: 1923 if (rl_src2.is_const) { 1924 isConstSuccess = GenLongLongImm(rl_dest, rl_src1, rl_src2, opcode); 1925 } else { 1926 DCHECK(rl_src1.is_const); 1927 isConstSuccess = GenLongLongImm(rl_dest, rl_src2, rl_src1, opcode); 1928 } 1929 break; 1930 case Instruction::SUB_LONG: 1931 case Instruction::SUB_LONG_2ADDR: 1932 if (rl_src2.is_const) { 1933 isConstSuccess = GenLongLongImm(rl_dest, rl_src1, rl_src2, opcode); 1934 } else { 1935 GenSubLong(opcode, rl_dest, rl_src1, rl_src2); 1936 isConstSuccess = true; 1937 } 1938 break; 1939 case Instruction::ADD_LONG_2ADDR: 1940 case Instruction::OR_LONG_2ADDR: 1941 case Instruction::XOR_LONG_2ADDR: 1942 case Instruction::AND_LONG_2ADDR: 1943 if (rl_src2.is_const) { 1944 if (GenerateTwoOperandInstructions()) { 1945 isConstSuccess = GenLongImm(rl_dest, rl_src2, opcode); 1946 } else { 1947 isConstSuccess = GenLongLongImm(rl_dest, rl_src1, rl_src2, opcode); 1948 } 1949 } else { 1950 DCHECK(rl_src1.is_const); 1951 isConstSuccess = GenLongLongImm(rl_dest, rl_src2, rl_src1, opcode); 1952 } 1953 break; 1954 default: 1955 isConstSuccess = false; 1956 break; 1957 } 1958 1959 if (!isConstSuccess) { 1960 // Default - bail to non-const handler. 1961 GenArithOpLong(opcode, rl_dest, rl_src1, rl_src2); 1962 } 1963} 1964 1965bool X86Mir2Lir::IsNoOp(Instruction::Code op, int32_t value) { 1966 switch (op) { 1967 case Instruction::AND_LONG_2ADDR: 1968 case Instruction::AND_LONG: 1969 return value == -1; 1970 case Instruction::OR_LONG: 1971 case Instruction::OR_LONG_2ADDR: 1972 case Instruction::XOR_LONG: 1973 case Instruction::XOR_LONG_2ADDR: 1974 return value == 0; 1975 default: 1976 return false; 1977 } 1978} 1979 1980X86OpCode X86Mir2Lir::GetOpcode(Instruction::Code op, RegLocation dest, RegLocation rhs, 1981 bool is_high_op) { 1982 bool rhs_in_mem = rhs.location != kLocPhysReg; 1983 bool dest_in_mem = dest.location != kLocPhysReg; 1984 bool is64Bit = Gen64Bit(); 1985 DCHECK(!rhs_in_mem || !dest_in_mem); 1986 switch (op) { 1987 case Instruction::ADD_LONG: 1988 case Instruction::ADD_LONG_2ADDR: 1989 if (dest_in_mem) { 1990 return is64Bit ? kX86Add64MR : is_high_op ? kX86Adc32MR : kX86Add32MR; 1991 } else if (rhs_in_mem) { 1992 return is64Bit ? kX86Add64RM : is_high_op ? kX86Adc32RM : kX86Add32RM; 1993 } 1994 return is64Bit ? kX86Add64RR : is_high_op ? kX86Adc32RR : kX86Add32RR; 1995 case Instruction::SUB_LONG: 1996 case Instruction::SUB_LONG_2ADDR: 1997 if (dest_in_mem) { 1998 return is64Bit ? kX86Sub64MR : is_high_op ? kX86Sbb32MR : kX86Sub32MR; 1999 } else if (rhs_in_mem) { 2000 return is64Bit ? kX86Sub64RM : is_high_op ? kX86Sbb32RM : kX86Sub32RM; 2001 } 2002 return is64Bit ? kX86Sub64RR : is_high_op ? kX86Sbb32RR : kX86Sub32RR; 2003 case Instruction::AND_LONG_2ADDR: 2004 case Instruction::AND_LONG: 2005 if (dest_in_mem) { 2006 return is64Bit ? kX86And64MR : kX86And32MR; 2007 } 2008 if (is64Bit) { 2009 return rhs_in_mem ? kX86And64RM : kX86And64RR; 2010 } 2011 return rhs_in_mem ? kX86And32RM : kX86And32RR; 2012 case Instruction::OR_LONG: 2013 case Instruction::OR_LONG_2ADDR: 2014 if (dest_in_mem) { 2015 return is64Bit ? kX86Or64MR : kX86Or32MR; 2016 } 2017 if (is64Bit) { 2018 return rhs_in_mem ? kX86Or64RM : kX86Or64RR; 2019 } 2020 return rhs_in_mem ? kX86Or32RM : kX86Or32RR; 2021 case Instruction::XOR_LONG: 2022 case Instruction::XOR_LONG_2ADDR: 2023 if (dest_in_mem) { 2024 return is64Bit ? kX86Xor64MR : kX86Xor32MR; 2025 } 2026 if (is64Bit) { 2027 return rhs_in_mem ? kX86Xor64RM : kX86Xor64RR; 2028 } 2029 return rhs_in_mem ? kX86Xor32RM : kX86Xor32RR; 2030 default: 2031 LOG(FATAL) << "Unexpected opcode: " << op; 2032 return kX86Add32RR; 2033 } 2034} 2035 2036X86OpCode X86Mir2Lir::GetOpcode(Instruction::Code op, RegLocation loc, bool is_high_op, 2037 int32_t value) { 2038 bool in_mem = loc.location != kLocPhysReg; 2039 bool is64Bit = Gen64Bit(); 2040 bool byte_imm = IS_SIMM8(value); 2041 DCHECK(in_mem || !loc.reg.IsFloat()); 2042 switch (op) { 2043 case Instruction::ADD_LONG: 2044 case Instruction::ADD_LONG_2ADDR: 2045 if (byte_imm) { 2046 if (in_mem) { 2047 return is64Bit ? kX86Add64MI8 : is_high_op ? kX86Adc32MI8 : kX86Add32MI8; 2048 } 2049 return is64Bit ? kX86Add64RI8 : is_high_op ? kX86Adc32RI8 : kX86Add32RI8; 2050 } 2051 if (in_mem) { 2052 return is64Bit ? kX86Add64MI : is_high_op ? kX86Adc32MI : kX86Add32MI; 2053 } 2054 return is64Bit ? kX86Add64RI : is_high_op ? kX86Adc32RI : kX86Add32RI; 2055 case Instruction::SUB_LONG: 2056 case Instruction::SUB_LONG_2ADDR: 2057 if (byte_imm) { 2058 if (in_mem) { 2059 return is64Bit ? kX86Sub64MI8 : is_high_op ? kX86Sbb32MI8 : kX86Sub32MI8; 2060 } 2061 return is64Bit ? kX86Sub64RI8 : is_high_op ? kX86Sbb32RI8 : kX86Sub32RI8; 2062 } 2063 if (in_mem) { 2064 return is64Bit ? kX86Sub64MI : is_high_op ? kX86Sbb32MI : kX86Sub32MI; 2065 } 2066 return is64Bit ? kX86Sub64RI : is_high_op ? kX86Sbb32RI : kX86Sub32RI; 2067 case Instruction::AND_LONG_2ADDR: 2068 case Instruction::AND_LONG: 2069 if (byte_imm) { 2070 if (is64Bit) { 2071 return in_mem ? kX86And64MI8 : kX86And64RI8; 2072 } 2073 return in_mem ? kX86And32MI8 : kX86And32RI8; 2074 } 2075 if (is64Bit) { 2076 return in_mem ? kX86And64MI : kX86And64RI; 2077 } 2078 return in_mem ? kX86And32MI : kX86And32RI; 2079 case Instruction::OR_LONG: 2080 case Instruction::OR_LONG_2ADDR: 2081 if (byte_imm) { 2082 if (is64Bit) { 2083 return in_mem ? kX86Or64MI8 : kX86Or64RI8; 2084 } 2085 return in_mem ? kX86Or32MI8 : kX86Or32RI8; 2086 } 2087 if (is64Bit) { 2088 return in_mem ? kX86Or64MI : kX86Or64RI; 2089 } 2090 return in_mem ? kX86Or32MI : kX86Or32RI; 2091 case Instruction::XOR_LONG: 2092 case Instruction::XOR_LONG_2ADDR: 2093 if (byte_imm) { 2094 if (is64Bit) { 2095 return in_mem ? kX86Xor64MI8 : kX86Xor64RI8; 2096 } 2097 return in_mem ? kX86Xor32MI8 : kX86Xor32RI8; 2098 } 2099 if (is64Bit) { 2100 return in_mem ? kX86Xor64MI : kX86Xor64RI; 2101 } 2102 return in_mem ? kX86Xor32MI : kX86Xor32RI; 2103 default: 2104 LOG(FATAL) << "Unexpected opcode: " << op; 2105 return kX86Add32MI; 2106 } 2107} 2108 2109bool X86Mir2Lir::GenLongImm(RegLocation rl_dest, RegLocation rl_src, Instruction::Code op) { 2110 DCHECK(rl_src.is_const); 2111 int64_t val = mir_graph_->ConstantValueWide(rl_src); 2112 2113 if (Gen64Bit()) { 2114 // We can do with imm only if it fits 32 bit 2115 if (val != (static_cast<int64_t>(static_cast<int32_t>(val)))) { 2116 return false; 2117 } 2118 2119 rl_dest = UpdateLocWideTyped(rl_dest, kCoreReg); 2120 2121 if ((rl_dest.location == kLocDalvikFrame) || 2122 (rl_dest.location == kLocCompilerTemp)) { 2123 int r_base = TargetReg(kSp).GetReg(); 2124 int displacement = SRegOffset(rl_dest.s_reg_low); 2125 2126 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 2127 X86OpCode x86op = GetOpcode(op, rl_dest, false, val); 2128 LIR *lir = NewLIR3(x86op, r_base, displacement + LOWORD_OFFSET, val); 2129 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 2130 true /* is_load */, true /* is64bit */); 2131 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 2132 false /* is_load */, true /* is64bit */); 2133 return true; 2134 } 2135 2136 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 2137 DCHECK_EQ(rl_result.location, kLocPhysReg); 2138 DCHECK(!rl_result.reg.IsFloat()); 2139 2140 X86OpCode x86op = GetOpcode(op, rl_result, false, val); 2141 NewLIR2(x86op, rl_result.reg.GetReg(), val); 2142 2143 StoreValueWide(rl_dest, rl_result); 2144 return true; 2145 } 2146 2147 int32_t val_lo = Low32Bits(val); 2148 int32_t val_hi = High32Bits(val); 2149 rl_dest = UpdateLocWideTyped(rl_dest, kCoreReg); 2150 2151 // Can we just do this into memory? 2152 if ((rl_dest.location == kLocDalvikFrame) || 2153 (rl_dest.location == kLocCompilerTemp)) { 2154 int r_base = TargetReg(kSp).GetReg(); 2155 int displacement = SRegOffset(rl_dest.s_reg_low); 2156 2157 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 2158 if (!IsNoOp(op, val_lo)) { 2159 X86OpCode x86op = GetOpcode(op, rl_dest, false, val_lo); 2160 LIR *lir = NewLIR3(x86op, r_base, displacement + LOWORD_OFFSET, val_lo); 2161 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 2162 true /* is_load */, true /* is64bit */); 2163 AnnotateDalvikRegAccess(lir, (displacement + LOWORD_OFFSET) >> 2, 2164 false /* is_load */, true /* is64bit */); 2165 } 2166 if (!IsNoOp(op, val_hi)) { 2167 X86OpCode x86op = GetOpcode(op, rl_dest, true, val_hi); 2168 LIR *lir = NewLIR3(x86op, r_base, displacement + HIWORD_OFFSET, val_hi); 2169 AnnotateDalvikRegAccess(lir, (displacement + HIWORD_OFFSET) >> 2, 2170 true /* is_load */, true /* is64bit */); 2171 AnnotateDalvikRegAccess(lir, (displacement + HIWORD_OFFSET) >> 2, 2172 false /* is_load */, true /* is64bit */); 2173 } 2174 return true; 2175 } 2176 2177 RegLocation rl_result = EvalLocWide(rl_dest, kCoreReg, true); 2178 DCHECK_EQ(rl_result.location, kLocPhysReg); 2179 DCHECK(!rl_result.reg.IsFloat()); 2180 2181 if (!IsNoOp(op, val_lo)) { 2182 X86OpCode x86op = GetOpcode(op, rl_result, false, val_lo); 2183 NewLIR2(x86op, rl_result.reg.GetLowReg(), val_lo); 2184 } 2185 if (!IsNoOp(op, val_hi)) { 2186 X86OpCode x86op = GetOpcode(op, rl_result, true, val_hi); 2187 NewLIR2(x86op, rl_result.reg.GetHighReg(), val_hi); 2188 } 2189 StoreValueWide(rl_dest, rl_result); 2190 return true; 2191} 2192 2193bool X86Mir2Lir::GenLongLongImm(RegLocation rl_dest, RegLocation rl_src1, 2194 RegLocation rl_src2, Instruction::Code op) { 2195 DCHECK(rl_src2.is_const); 2196 int64_t val = mir_graph_->ConstantValueWide(rl_src2); 2197 2198 if (Gen64Bit()) { 2199 // We can do with imm only if it fits 32 bit 2200 if (val != (static_cast<int64_t>(static_cast<int32_t>(val)))) { 2201 return false; 2202 } 2203 if (rl_dest.location == kLocPhysReg && 2204 rl_src1.location == kLocPhysReg && !rl_dest.reg.IsFloat()) { 2205 X86OpCode x86op = GetOpcode(op, rl_dest, false, val); 2206 OpRegCopy(rl_dest.reg, rl_src1.reg); 2207 NewLIR2(x86op, rl_dest.reg.GetReg(), val); 2208 StoreFinalValueWide(rl_dest, rl_dest); 2209 return true; 2210 } 2211 2212 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 2213 // We need the values to be in a temporary 2214 RegLocation rl_result = ForceTempWide(rl_src1); 2215 2216 X86OpCode x86op = GetOpcode(op, rl_result, false, val); 2217 NewLIR2(x86op, rl_result.reg.GetReg(), val); 2218 2219 StoreFinalValueWide(rl_dest, rl_result); 2220 return true; 2221 } 2222 2223 int32_t val_lo = Low32Bits(val); 2224 int32_t val_hi = High32Bits(val); 2225 rl_dest = UpdateLocWideTyped(rl_dest, kCoreReg); 2226 rl_src1 = UpdateLocWideTyped(rl_src1, kCoreReg); 2227 2228 // Can we do this directly into the destination registers? 2229 if (rl_dest.location == kLocPhysReg && rl_src1.location == kLocPhysReg && 2230 rl_dest.reg.GetLowReg() == rl_src1.reg.GetLowReg() && 2231 rl_dest.reg.GetHighReg() == rl_src1.reg.GetHighReg() && !rl_dest.reg.IsFloat()) { 2232 if (!IsNoOp(op, val_lo)) { 2233 X86OpCode x86op = GetOpcode(op, rl_dest, false, val_lo); 2234 NewLIR2(x86op, rl_dest.reg.GetLowReg(), val_lo); 2235 } 2236 if (!IsNoOp(op, val_hi)) { 2237 X86OpCode x86op = GetOpcode(op, rl_dest, true, val_hi); 2238 NewLIR2(x86op, rl_dest.reg.GetHighReg(), val_hi); 2239 } 2240 2241 StoreFinalValueWide(rl_dest, rl_dest); 2242 return true; 2243 } 2244 2245 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 2246 DCHECK_EQ(rl_src1.location, kLocPhysReg); 2247 2248 // We need the values to be in a temporary 2249 RegLocation rl_result = ForceTempWide(rl_src1); 2250 if (!IsNoOp(op, val_lo)) { 2251 X86OpCode x86op = GetOpcode(op, rl_result, false, val_lo); 2252 NewLIR2(x86op, rl_result.reg.GetLowReg(), val_lo); 2253 } 2254 if (!IsNoOp(op, val_hi)) { 2255 X86OpCode x86op = GetOpcode(op, rl_result, true, val_hi); 2256 NewLIR2(x86op, rl_result.reg.GetHighReg(), val_hi); 2257 } 2258 2259 StoreFinalValueWide(rl_dest, rl_result); 2260 return true; 2261} 2262 2263// For final classes there are no sub-classes to check and so we can answer the instance-of 2264// question with simple comparisons. Use compares to memory and SETEQ to optimize for x86. 2265void X86Mir2Lir::GenInstanceofFinal(bool use_declaring_class, uint32_t type_idx, 2266 RegLocation rl_dest, RegLocation rl_src) { 2267 RegLocation object = LoadValue(rl_src, kRefReg); 2268 RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); 2269 RegStorage result_reg = rl_result.reg; 2270 2271 // For 32-bit, SETcc only works with EAX..EDX. 2272 if (result_reg == object.reg || !IsByteRegister(result_reg)) { 2273 result_reg = AllocateByteRegister(); 2274 } 2275 2276 // Assume that there is no match. 2277 LoadConstant(result_reg, 0); 2278 LIR* null_branchover = OpCmpImmBranch(kCondEq, object.reg, 0, NULL); 2279 2280 // We will use this register to compare to memory below. 2281 // References are 32 bit in memory, and 64 bit in registers (in 64 bit mode). 2282 // For this reason, force allocation of a 32 bit register to use, so that the 2283 // compare to memory will be done using a 32 bit comparision. 2284 // The LoadRefDisp(s) below will work normally, even in 64 bit mode. 2285 RegStorage check_class = AllocTemp(); 2286 2287 // If Method* is already in a register, we can save a copy. 2288 RegLocation rl_method = mir_graph_->GetMethodLoc(); 2289 int32_t offset_of_type = mirror::Array::DataOffset(sizeof(mirror::HeapReference<mirror::Class*>)).Int32Value() + 2290 (sizeof(mirror::HeapReference<mirror::Class*>) * type_idx); 2291 2292 if (rl_method.location == kLocPhysReg) { 2293 if (use_declaring_class) { 2294 LoadRefDisp(rl_method.reg, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), 2295 check_class, kNotVolatile); 2296 } else { 2297 LoadRefDisp(rl_method.reg, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), 2298 check_class, kNotVolatile); 2299 LoadRefDisp(check_class, offset_of_type, check_class, kNotVolatile); 2300 } 2301 } else { 2302 LoadCurrMethodDirect(check_class); 2303 if (use_declaring_class) { 2304 LoadRefDisp(check_class, mirror::ArtMethod::DeclaringClassOffset().Int32Value(), 2305 check_class, kNotVolatile); 2306 } else { 2307 LoadRefDisp(check_class, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), 2308 check_class, kNotVolatile); 2309 LoadRefDisp(check_class, offset_of_type, check_class, kNotVolatile); 2310 } 2311 } 2312 2313 // Compare the computed class to the class in the object. 2314 DCHECK_EQ(object.location, kLocPhysReg); 2315 OpRegMem(kOpCmp, check_class, object.reg, mirror::Object::ClassOffset().Int32Value()); 2316 2317 // Set the low byte of the result to 0 or 1 from the compare condition code. 2318 NewLIR2(kX86Set8R, result_reg.GetReg(), kX86CondEq); 2319 2320 LIR* target = NewLIR0(kPseudoTargetLabel); 2321 null_branchover->target = target; 2322 FreeTemp(check_class); 2323 if (IsTemp(result_reg)) { 2324 OpRegCopy(rl_result.reg, result_reg); 2325 FreeTemp(result_reg); 2326 } 2327 StoreValue(rl_dest, rl_result); 2328} 2329 2330void X86Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_known_final, 2331 bool type_known_abstract, bool use_declaring_class, 2332 bool can_assume_type_is_in_dex_cache, 2333 uint32_t type_idx, RegLocation rl_dest, 2334 RegLocation rl_src) { 2335 FlushAllRegs(); 2336 // May generate a call - use explicit registers. 2337 LockCallTemps(); 2338 LoadCurrMethodDirect(TargetReg(kArg1)); // kArg1 gets current Method*. 2339 RegStorage class_reg = TargetReg(kArg2); // kArg2 will hold the Class*. 2340 // Reference must end up in kArg0. 2341 if (needs_access_check) { 2342 // Check we have access to type_idx and if not throw IllegalAccessError, 2343 // Caller function returns Class* in kArg0. 2344 if (cu_->target64) { 2345 CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(8, pInitializeTypeAndVerifyAccess), 2346 type_idx, true); 2347 } else { 2348 CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(4, pInitializeTypeAndVerifyAccess), 2349 type_idx, true); 2350 } 2351 OpRegCopy(class_reg, TargetReg(kRet0)); 2352 LoadValueDirectFixed(rl_src, TargetReg(kArg0)); 2353 } else if (use_declaring_class) { 2354 LoadValueDirectFixed(rl_src, TargetReg(kArg0)); 2355 LoadRefDisp(TargetReg(kArg1), mirror::ArtMethod::DeclaringClassOffset().Int32Value(), 2356 class_reg, kNotVolatile); 2357 } else { 2358 // Load dex cache entry into class_reg (kArg2). 2359 LoadValueDirectFixed(rl_src, TargetReg(kArg0)); 2360 LoadRefDisp(TargetReg(kArg1), mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), 2361 class_reg, kNotVolatile); 2362 int32_t offset_of_type = 2363 mirror::Array::DataOffset(sizeof(mirror::HeapReference<mirror::Class*>)).Int32Value() + 2364 (sizeof(mirror::HeapReference<mirror::Class*>) * type_idx); 2365 LoadRefDisp(class_reg, offset_of_type, class_reg, kNotVolatile); 2366 if (!can_assume_type_is_in_dex_cache) { 2367 // Need to test presence of type in dex cache at runtime. 2368 LIR* hop_branch = OpCmpImmBranch(kCondNe, class_reg, 0, NULL); 2369 // Type is not resolved. Call out to helper, which will return resolved type in kRet0/kArg0. 2370 if (cu_->target64) { 2371 CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(8, pInitializeType), type_idx, true); 2372 } else { 2373 CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(4, pInitializeType), type_idx, true); 2374 } 2375 OpRegCopy(TargetReg(kArg2), TargetReg(kRet0)); // Align usage with fast path. 2376 LoadValueDirectFixed(rl_src, TargetReg(kArg0)); /* Reload Ref. */ 2377 // Rejoin code paths 2378 LIR* hop_target = NewLIR0(kPseudoTargetLabel); 2379 hop_branch->target = hop_target; 2380 } 2381 } 2382 /* kArg0 is ref, kArg2 is class. If ref==null, use directly as bool result. */ 2383 RegLocation rl_result = GetReturn(kRefReg); 2384 2385 // On x86-64 kArg0 is not EAX, so we have to copy ref from kArg0 to EAX. 2386 if (Gen64Bit()) { 2387 OpRegCopy(rl_result.reg, TargetReg(kArg0)); 2388 } 2389 2390 // For 32-bit, SETcc only works with EAX..EDX. 2391 DCHECK_LT(rl_result.reg.GetRegNum(), 4); 2392 2393 // Is the class NULL? 2394 LIR* branch1 = OpCmpImmBranch(kCondEq, TargetReg(kArg0), 0, NULL); 2395 2396 /* Load object->klass_. */ 2397 DCHECK_EQ(mirror::Object::ClassOffset().Int32Value(), 0); 2398 LoadRefDisp(TargetReg(kArg0), mirror::Object::ClassOffset().Int32Value(), TargetReg(kArg1), 2399 kNotVolatile); 2400 /* kArg0 is ref, kArg1 is ref->klass_, kArg2 is class. */ 2401 LIR* branchover = nullptr; 2402 if (type_known_final) { 2403 // Ensure top 3 bytes of result are 0. 2404 LoadConstant(rl_result.reg, 0); 2405 OpRegReg(kOpCmp, TargetReg(kArg1), TargetReg(kArg2)); 2406 // Set the low byte of the result to 0 or 1 from the compare condition code. 2407 NewLIR2(kX86Set8R, rl_result.reg.GetReg(), kX86CondEq); 2408 } else { 2409 if (!type_known_abstract) { 2410 LoadConstant(rl_result.reg, 1); // Assume result succeeds. 2411 branchover = OpCmpBranch(kCondEq, TargetReg(kArg1), TargetReg(kArg2), NULL); 2412 } 2413 OpRegCopy(TargetReg(kArg0), TargetReg(kArg2)); 2414 if (cu_->target64) { 2415 OpThreadMem(kOpBlx, QUICK_ENTRYPOINT_OFFSET(8, pInstanceofNonTrivial)); 2416 } else { 2417 OpThreadMem(kOpBlx, QUICK_ENTRYPOINT_OFFSET(4, pInstanceofNonTrivial)); 2418 } 2419 } 2420 // TODO: only clobber when type isn't final? 2421 ClobberCallerSave(); 2422 /* Branch targets here. */ 2423 LIR* target = NewLIR0(kPseudoTargetLabel); 2424 StoreValue(rl_dest, rl_result); 2425 branch1->target = target; 2426 if (branchover != nullptr) { 2427 branchover->target = target; 2428 } 2429} 2430 2431void X86Mir2Lir::GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest, 2432 RegLocation rl_lhs, RegLocation rl_rhs) { 2433 OpKind op = kOpBkpt; 2434 bool is_div_rem = false; 2435 bool unary = false; 2436 bool shift_op = false; 2437 bool is_two_addr = false; 2438 RegLocation rl_result; 2439 switch (opcode) { 2440 case Instruction::NEG_INT: 2441 op = kOpNeg; 2442 unary = true; 2443 break; 2444 case Instruction::NOT_INT: 2445 op = kOpMvn; 2446 unary = true; 2447 break; 2448 case Instruction::ADD_INT_2ADDR: 2449 is_two_addr = true; 2450 // Fallthrough 2451 case Instruction::ADD_INT: 2452 op = kOpAdd; 2453 break; 2454 case Instruction::SUB_INT_2ADDR: 2455 is_two_addr = true; 2456 // Fallthrough 2457 case Instruction::SUB_INT: 2458 op = kOpSub; 2459 break; 2460 case Instruction::MUL_INT_2ADDR: 2461 is_two_addr = true; 2462 // Fallthrough 2463 case Instruction::MUL_INT: 2464 op = kOpMul; 2465 break; 2466 case Instruction::DIV_INT_2ADDR: 2467 is_two_addr = true; 2468 // Fallthrough 2469 case Instruction::DIV_INT: 2470 op = kOpDiv; 2471 is_div_rem = true; 2472 break; 2473 /* NOTE: returns in kArg1 */ 2474 case Instruction::REM_INT_2ADDR: 2475 is_two_addr = true; 2476 // Fallthrough 2477 case Instruction::REM_INT: 2478 op = kOpRem; 2479 is_div_rem = true; 2480 break; 2481 case Instruction::AND_INT_2ADDR: 2482 is_two_addr = true; 2483 // Fallthrough 2484 case Instruction::AND_INT: 2485 op = kOpAnd; 2486 break; 2487 case Instruction::OR_INT_2ADDR: 2488 is_two_addr = true; 2489 // Fallthrough 2490 case Instruction::OR_INT: 2491 op = kOpOr; 2492 break; 2493 case Instruction::XOR_INT_2ADDR: 2494 is_two_addr = true; 2495 // Fallthrough 2496 case Instruction::XOR_INT: 2497 op = kOpXor; 2498 break; 2499 case Instruction::SHL_INT_2ADDR: 2500 is_two_addr = true; 2501 // Fallthrough 2502 case Instruction::SHL_INT: 2503 shift_op = true; 2504 op = kOpLsl; 2505 break; 2506 case Instruction::SHR_INT_2ADDR: 2507 is_two_addr = true; 2508 // Fallthrough 2509 case Instruction::SHR_INT: 2510 shift_op = true; 2511 op = kOpAsr; 2512 break; 2513 case Instruction::USHR_INT_2ADDR: 2514 is_two_addr = true; 2515 // Fallthrough 2516 case Instruction::USHR_INT: 2517 shift_op = true; 2518 op = kOpLsr; 2519 break; 2520 default: 2521 LOG(FATAL) << "Invalid word arith op: " << opcode; 2522 } 2523 2524 // Can we convert to a two address instruction? 2525 if (!is_two_addr && 2526 (mir_graph_->SRegToVReg(rl_dest.s_reg_low) == 2527 mir_graph_->SRegToVReg(rl_lhs.s_reg_low))) { 2528 is_two_addr = true; 2529 } 2530 2531 if (!GenerateTwoOperandInstructions()) { 2532 is_two_addr = false; 2533 } 2534 2535 // Get the div/rem stuff out of the way. 2536 if (is_div_rem) { 2537 rl_result = GenDivRem(rl_dest, rl_lhs, rl_rhs, op == kOpDiv, true); 2538 StoreValue(rl_dest, rl_result); 2539 return; 2540 } 2541 2542 // If we generate any memory access below, it will reference a dalvik reg. 2543 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 2544 2545 if (unary) { 2546 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2547 rl_result = UpdateLocTyped(rl_dest, kCoreReg); 2548 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2549 OpRegReg(op, rl_result.reg, rl_lhs.reg); 2550 } else { 2551 if (shift_op) { 2552 // X86 doesn't require masking and must use ECX. 2553 RegStorage t_reg = TargetReg(kCount); // rCX 2554 LoadValueDirectFixed(rl_rhs, t_reg); 2555 if (is_two_addr) { 2556 // Can we do this directly into memory? 2557 rl_result = UpdateLocTyped(rl_dest, kCoreReg); 2558 rl_rhs = LoadValue(rl_rhs, kCoreReg); 2559 if (rl_result.location != kLocPhysReg) { 2560 // Okay, we can do this into memory 2561 OpMemReg(op, rl_result, t_reg.GetReg()); 2562 FreeTemp(t_reg); 2563 return; 2564 } else if (!rl_result.reg.IsFloat()) { 2565 // Can do this directly into the result register 2566 OpRegReg(op, rl_result.reg, t_reg); 2567 FreeTemp(t_reg); 2568 StoreFinalValue(rl_dest, rl_result); 2569 return; 2570 } 2571 } 2572 // Three address form, or we can't do directly. 2573 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2574 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2575 OpRegRegReg(op, rl_result.reg, rl_lhs.reg, t_reg); 2576 FreeTemp(t_reg); 2577 } else { 2578 // Multiply is 3 operand only (sort of). 2579 if (is_two_addr && op != kOpMul) { 2580 // Can we do this directly into memory? 2581 rl_result = UpdateLocTyped(rl_dest, kCoreReg); 2582 if (rl_result.location == kLocPhysReg) { 2583 // Ensure res is in a core reg 2584 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2585 // Can we do this from memory directly? 2586 rl_rhs = UpdateLocTyped(rl_rhs, kCoreReg); 2587 if (rl_rhs.location != kLocPhysReg) { 2588 OpRegMem(op, rl_result.reg, rl_rhs); 2589 StoreFinalValue(rl_dest, rl_result); 2590 return; 2591 } else if (!rl_rhs.reg.IsFloat()) { 2592 OpRegReg(op, rl_result.reg, rl_rhs.reg); 2593 StoreFinalValue(rl_dest, rl_result); 2594 return; 2595 } 2596 } 2597 rl_rhs = LoadValue(rl_rhs, kCoreReg); 2598 // It might happen rl_rhs and rl_dest are the same VR 2599 // in this case rl_dest is in reg after LoadValue while 2600 // rl_result is not updated yet, so do this 2601 rl_result = UpdateLocTyped(rl_dest, kCoreReg); 2602 if (rl_result.location != kLocPhysReg) { 2603 // Okay, we can do this into memory. 2604 OpMemReg(op, rl_result, rl_rhs.reg.GetReg()); 2605 return; 2606 } else if (!rl_result.reg.IsFloat()) { 2607 // Can do this directly into the result register. 2608 OpRegReg(op, rl_result.reg, rl_rhs.reg); 2609 StoreFinalValue(rl_dest, rl_result); 2610 return; 2611 } else { 2612 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2613 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2614 OpRegRegReg(op, rl_result.reg, rl_lhs.reg, rl_rhs.reg); 2615 } 2616 } else { 2617 // Try to use reg/memory instructions. 2618 rl_lhs = UpdateLocTyped(rl_lhs, kCoreReg); 2619 rl_rhs = UpdateLocTyped(rl_rhs, kCoreReg); 2620 // We can't optimize with FP registers. 2621 if (!IsOperationSafeWithoutTemps(rl_lhs, rl_rhs)) { 2622 // Something is difficult, so fall back to the standard case. 2623 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2624 rl_rhs = LoadValue(rl_rhs, kCoreReg); 2625 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2626 OpRegRegReg(op, rl_result.reg, rl_lhs.reg, rl_rhs.reg); 2627 } else { 2628 // We can optimize by moving to result and using memory operands. 2629 if (rl_rhs.location != kLocPhysReg) { 2630 // Force LHS into result. 2631 // We should be careful with order here 2632 // If rl_dest and rl_lhs points to the same VR we should load first 2633 // If the are different we should find a register first for dest 2634 if (mir_graph_->SRegToVReg(rl_dest.s_reg_low) == 2635 mir_graph_->SRegToVReg(rl_lhs.s_reg_low)) { 2636 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2637 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2638 // No-op if these are the same. 2639 OpRegCopy(rl_result.reg, rl_lhs.reg); 2640 } else { 2641 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2642 LoadValueDirect(rl_lhs, rl_result.reg); 2643 } 2644 OpRegMem(op, rl_result.reg, rl_rhs); 2645 } else if (rl_lhs.location != kLocPhysReg) { 2646 // RHS is in a register; LHS is in memory. 2647 if (op != kOpSub) { 2648 // Force RHS into result and operate on memory. 2649 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2650 OpRegCopy(rl_result.reg, rl_rhs.reg); 2651 OpRegMem(op, rl_result.reg, rl_lhs); 2652 } else { 2653 // Subtraction isn't commutative. 2654 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2655 rl_rhs = LoadValue(rl_rhs, kCoreReg); 2656 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2657 OpRegRegReg(op, rl_result.reg, rl_lhs.reg, rl_rhs.reg); 2658 } 2659 } else { 2660 // Both are in registers. 2661 rl_lhs = LoadValue(rl_lhs, kCoreReg); 2662 rl_rhs = LoadValue(rl_rhs, kCoreReg); 2663 rl_result = EvalLoc(rl_dest, kCoreReg, true); 2664 OpRegRegReg(op, rl_result.reg, rl_lhs.reg, rl_rhs.reg); 2665 } 2666 } 2667 } 2668 } 2669 } 2670 StoreValue(rl_dest, rl_result); 2671} 2672 2673bool X86Mir2Lir::IsOperationSafeWithoutTemps(RegLocation rl_lhs, RegLocation rl_rhs) { 2674 // If we have non-core registers, then we can't do good things. 2675 if (rl_lhs.location == kLocPhysReg && rl_lhs.reg.IsFloat()) { 2676 return false; 2677 } 2678 if (rl_rhs.location == kLocPhysReg && rl_rhs.reg.IsFloat()) { 2679 return false; 2680 } 2681 2682 // Everything will be fine :-). 2683 return true; 2684} 2685 2686void X86Mir2Lir::GenIntToLong(RegLocation rl_dest, RegLocation rl_src) { 2687 if (!Gen64Bit()) { 2688 Mir2Lir::GenIntToLong(rl_dest, rl_src); 2689 return; 2690 } 2691 rl_src = UpdateLoc(rl_src); 2692 RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true); 2693 if (rl_src.location == kLocPhysReg) { 2694 NewLIR2(kX86MovsxdRR, rl_result.reg.GetReg(), rl_src.reg.GetReg()); 2695 } else { 2696 int displacement = SRegOffset(rl_src.s_reg_low); 2697 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 2698 LIR *m = NewLIR3(kX86MovsxdRM, rl_result.reg.GetReg(), rs_rX86_SP.GetReg(), 2699 displacement + LOWORD_OFFSET); 2700 AnnotateDalvikRegAccess(m, (displacement + LOWORD_OFFSET) >> 2, 2701 true /* is_load */, true /* is_64bit */); 2702 } 2703 StoreValueWide(rl_dest, rl_result); 2704} 2705 2706void X86Mir2Lir::GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest, 2707 RegLocation rl_src1, RegLocation rl_shift) { 2708 if (!Gen64Bit()) { 2709 Mir2Lir::GenShiftOpLong(opcode, rl_dest, rl_src1, rl_shift); 2710 return; 2711 } 2712 2713 bool is_two_addr = false; 2714 OpKind op = kOpBkpt; 2715 RegLocation rl_result; 2716 2717 switch (opcode) { 2718 case Instruction::SHL_LONG_2ADDR: 2719 is_two_addr = true; 2720 // Fallthrough 2721 case Instruction::SHL_LONG: 2722 op = kOpLsl; 2723 break; 2724 case Instruction::SHR_LONG_2ADDR: 2725 is_two_addr = true; 2726 // Fallthrough 2727 case Instruction::SHR_LONG: 2728 op = kOpAsr; 2729 break; 2730 case Instruction::USHR_LONG_2ADDR: 2731 is_two_addr = true; 2732 // Fallthrough 2733 case Instruction::USHR_LONG: 2734 op = kOpLsr; 2735 break; 2736 default: 2737 op = kOpBkpt; 2738 } 2739 2740 // X86 doesn't require masking and must use ECX. 2741 RegStorage t_reg = TargetReg(kCount); // rCX 2742 LoadValueDirectFixed(rl_shift, t_reg); 2743 if (is_two_addr) { 2744 // Can we do this directly into memory? 2745 rl_result = UpdateLocWideTyped(rl_dest, kCoreReg); 2746 if (rl_result.location != kLocPhysReg) { 2747 // Okay, we can do this into memory 2748 ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); 2749 OpMemReg(op, rl_result, t_reg.GetReg()); 2750 } else if (!rl_result.reg.IsFloat()) { 2751 // Can do this directly into the result register 2752 OpRegReg(op, rl_result.reg, t_reg); 2753 StoreFinalValueWide(rl_dest, rl_result); 2754 } 2755 } else { 2756 // Three address form, or we can't do directly. 2757 rl_src1 = LoadValueWide(rl_src1, kCoreReg); 2758 rl_result = EvalLocWide(rl_dest, kCoreReg, true); 2759 OpRegRegReg(op, rl_result.reg, rl_src1.reg, t_reg); 2760 StoreFinalValueWide(rl_dest, rl_result); 2761 } 2762 2763 FreeTemp(t_reg); 2764} 2765 2766} // namespace art 2767