Lines Matching refs:__
144 #define __ down_cast<CodeGeneratorMIPS*>(codegen)->GetAssembler()->
154 __ Bind(GetEntryLabel());
190 __ Bind(GetEntryLabel());
225 __ Bind(GetEntryLabel());
229 __ LoadConst32(calling_convention.GetRegisterAt(0), cls_->GetTypeIndex());
252 __ B(GetExitLabel());
283 __ Bind(GetEntryLabel());
288 __ LoadConst32(calling_convention.GetRegisterAt(0), string_index);
301 __ B(GetExitLabel());
316 __ Bind(GetEntryLabel());
344 __ Bind(GetEntryLabel());
354 __ B(GetReturnLabel());
356 __ B(mips_codegen->GetLabelOf(successor_));
389 __ Bind(GetEntryLabel());
424 __ B(GetExitLabel());
440 __ Bind(GetEntryLabel());
480 #undef __
481 #define __ down_cast<MipsAssembler*>(GetAssembler())->
486 __ FinalizeCode();
491 uint32_t new_position = __ GetAdjustedPosition(old_position);
499 frame_entry_interval->start = __ GetAdjustedPosition(frame_entry_interval->start);
500 frame_entry_interval->end = __ GetAdjustedPosition(frame_entry_interval->end);
502 it.second.start = __ GetAdjustedPosition(it.second.start);
503 it.second.end = __ GetAdjustedPosition(it.second.end);
506 it.code_interval.start = __ GetAdjustedPosition(it.code_interval.start);
507 it.code_interval.end = __ GetAdjustedPosition(it.code_interval.end);
542 __ Move(TMP, r2);
543 __ Move(r2, r1);
544 __ Move(r1, TMP);
549 __ MovS(FTMP, f2);
550 __ MovS(f2, f1);
551 __ MovS(f1, FTMP);
554 __ MovD(FTMP, f2);
555 __ MovD(f2, f1);
556 __ MovD(f1, FTMP);
566 __ Move(TMP, r2);
567 __ Mfc1(r2, f1);
568 __ Mtc1(TMP, f1);
573 __ Move(TMP, r2);
574 __ Move(r2, r1);
575 __ Move(r1, TMP);
578 __ Move(TMP, r2);
579 __ Move(r2, r1);
580 __ Move(r1, TMP);
594 __ Mfc1(TMP, f1);
595 __ MoveFromFpuHigh(AT, f1);
596 __ Mtc1(r2_l, f1);
597 __ MoveToFpuHigh(r2_h, f1);
598 __ Move(r2_l, TMP);
599 __ Move(r2_h, AT);
610 __ Move(TMP, reg);
611 __ LoadFromOffset(kLoadWord, reg, SP, offset);
612 __ StoreToOffset(kStoreWord, TMP, SP, offset);
623 __ Move(TMP, reg_l);
624 __ LoadFromOffset(kLoadWord, reg_l, SP, offset_l);
625 __ StoreToOffset(kStoreWord, TMP, SP, offset_l);
626 __ Move(TMP, reg_h);
627 __ LoadFromOffset(kLoadWord, reg_h, SP, offset_h);
628 __ StoreToOffset(kStoreWord, TMP, SP, offset_h);
635 __ Pop(static_cast<Register>(reg));
639 __ Push(static_cast<Register>(reg));
650 __ LoadFromOffset(kLoadWord,
654 __ LoadFromOffset(kLoadWord,
658 __ StoreToOffset(kStoreWord,
662 __ StoreToOffset(kStoreWord, TMP, SP, index1 + stack_offset);
673 __ Bind(&frame_entry_label_);
678 __ LoadFromOffset(kLoadWord,
703 __ IncreaseFrameSize(ofs);
709 __ Sw(reg, SP, ofs);
710 __ cfi().RelOffset(DWARFReg(reg), ofs);
721 __ Swc1(reg, SP, ofs);
722 __ Swc1(static_cast<FRegister>(reg + 1), SP, ofs + 4);
724 __ Mfhc1(TMP, reg);
725 __ Swc1(reg, SP, ofs);
726 __ Sw(TMP, SP, ofs + 4);
729 __ Sdc1(reg, SP, ofs);
731 // TODO: __ cfi().RelOffset(DWARFReg(reg), ofs);
738 __ IncreaseFrameSize(GetFrameSize() - FrameEntrySpillSize());
742 __ Sw(kMethodRegisterArgument, SP, kCurrentMethodStackOffset);
746 __ cfi().RememberState();
751 __ DecreaseFrameSize(GetFrameSize() - FrameEntrySpillSize());
768 __ Lwc1(reg, SP, ofs);
769 __ Lwc1(static_cast<FRegister>(reg + 1), SP, ofs + 4);
771 __ Lwc1(reg, SP, ofs);
772 __ Lw(TMP, SP, ofs + 4);
773 __ Mthc1(TMP, reg);
776 __ Ldc1(reg, SP, ofs);
779 // TODO: __ cfi().Restore(DWARFReg(reg));
786 __ Lw(reg, SP, ofs);
788 __ cfi().Restore(DWARFReg(reg));
793 __ DecreaseFrameSize(ofs);
796 __ Jr(RA);
797 __ Nop();
799 __ cfi().RestoreState();
800 __ cfi().DefCFAOffset(GetFrameSize());
804 __ Bind(GetLabelOf(block));
830 __ Move(destination.AsRegister<Register>(), source.AsRegister<Register>());
832 __ Mfc1(destination.AsRegister<Register>(), source.AsFpuRegister<FRegister>());
835 __ LoadFromOffset(kLoadWord, destination.AsRegister<Register>(), SP, source.GetStackIndex());
839 __ Mtc1(source.AsRegister<Register>(), destination.AsFpuRegister<FRegister>());
841 __ MovS(destination.AsFpuRegister<FRegister>(), source.AsFpuRegister<FRegister>());
844 __ LoadSFromOffset(destination.AsFpuRegister<FRegister>(), SP, source.GetStackIndex());
849 __ StoreToOffset(kStoreWord, source.AsRegister<Register>(), SP, destination.GetStackIndex());
851 __ StoreSToOffset(source.AsFpuRegister<FRegister>(), SP, destination.GetStackIndex());
854 __ LoadFromOffset(kLoadWord, TMP, SP, source.GetStackIndex());
855 __ StoreToOffset(kStoreWord, TMP, SP, destination.GetStackIndex());
867 __ Move(destination.AsRegisterPairHigh<Register>(), source.AsRegisterPairHigh<Register>());
868 __ Move(destination.AsRegisterPairLow<Register>(), source.AsRegisterPairLow<Register>());
873 __ Mfc1(dst_low, src);
874 __ MoveFromFpuHigh(dst_high, src);
879 __ LoadFromOffset(kLoadDoubleword, r, SP, off);
886 __ Mtc1(src_low, dst);
887 __ MoveToFpuHigh(src_high, dst);
889 __ MovD(destination.AsFpuRegister<FRegister>(), source.AsFpuRegister<FRegister>());
892 __ LoadDFromOffset(destination.AsFpuRegister<FRegister>(), SP, source.GetStackIndex());
898 __ StoreToOffset(kStoreDoubleword, source.AsRegisterPairLow<Register>(), SP, off);
900 __ StoreDToOffset(source.AsFpuRegister<FRegister>(), SP, off);
903 __ LoadFromOffset(kLoadWord, TMP, SP, source.GetStackIndex());
904 __ StoreToOffset(kStoreWord, TMP, SP, off);
905 __ LoadFromOffset(kLoadWord, TMP, SP, source.GetStackIndex() + 4);
906 __ StoreToOffset(kStoreWord, TMP, SP, off + 4);
917 __ LoadConst32(dst, value);
921 __ StoreConst32ToOffset(value, SP, destination.GetStackIndex(), TMP);
929 __ LoadConst64(r_h, r_l, value);
933 __ StoreConst64ToOffset(value, SP, destination.GetStackIndex(), TMP);
939 __ LoadSConst32(destination.AsFpuRegister<FRegister>(), value, TMP);
943 __ StoreConst32ToOffset(value, SP, destination.GetStackIndex(), TMP);
951 __ LoadDConst64(fd, value, TMP);
955 __ StoreConst64ToOffset(value, SP, destination.GetStackIndex(), TMP);
963 __ LoadConst32(dst, value);
981 __ Beqz(value, &done);
982 __ LoadFromOffset(kLoadWord,
986 __ Srl(temp, object, gc::accounting::CardTable::kCardShift);
987 __ Addu(temp, card, temp);
988 __ Sb(card, temp, 0);
989 __ Bind(&done);
1037 __ StoreToOffset(kStoreWord, Register(reg_id), SP, stack_index);
1042 __ LoadFromOffset(kLoadWord, Register(reg_id), SP, stack_index);
1047 __ StoreDToOffset(FRegister(reg_id), SP, stack_index);
1052 __ LoadDFromOffset(FRegister(reg_id), SP, stack_index);
1082 __ LoadFromOffset(kLoadWord, T9, TR, entry_point_offset);
1083 __ Jalr(T9);
1088 __ IncreaseFrameSize(kMipsDirectEntrypointRuntimeOffset); // Single instruction in delay slot.
1089 __ DecreaseFrameSize(kMipsDirectEntrypointRuntimeOffset);
1091 __ Nop(); // In delay slot.
1098 __ LoadFromOffset(kLoadWord, TMP, class_reg, mirror::Class::StatusOffset().Int32Value());
1099 __ LoadConst32(AT, mirror::Class::kStatusInitialized);
1100 __ Blt(TMP, AT, slow_path->GetEntryLabel());
1102 __ Sync(0);
1103 __ Bind(slow_path->GetExitLabel());
1107 __ Sync(0); // Only stype 0 is supported.
1116 __ LoadFromOffset(kLoadUnsignedHalfword,
1121 __ Bnez(TMP, slow_path->GetEntryLabel());
1122 __ Bind(slow_path->GetReturnLabel());
1124 __ Beqz(TMP, codegen_->GetLabelOf(successor));
1125 __ B(slow_path->GetEntryLabel());
1205 __ Andi(dst, lhs, rhs_imm);
1207 __ And(dst, lhs, rhs_reg);
1210 __ Ori(dst, lhs, rhs_imm);
1212 __ Or(dst, lhs, rhs_reg);
1215 __ Xori(dst, lhs, rhs_imm);
1217 __ Xor(dst, lhs, rhs_reg);
1220 __ Addiu(dst, lhs, rhs_imm);
1222 __ Addu(dst, lhs, rhs_reg);
1226 __ Addiu(dst, lhs, -rhs_imm);
1228 __ Subu(dst, lhs, rhs_reg);
1244 __ And(dst_low, lhs_low, rhs_low);
1245 __ And(dst_high, lhs_high, rhs_high);
1247 __ Or(dst_low, lhs_low, rhs_low);
1248 __ Or(dst_high, lhs_high, rhs_high);
1250 __ Xor(dst_low, lhs_low, rhs_low);
1251 __ Xor(dst_high, lhs_high, rhs_high);
1255 __ Slt(TMP, lhs_low, ZERO);
1256 __ Addu(dst_low, lhs_low, rhs_low);
1258 __ Addu(dst_low, lhs_low, rhs_low);
1260 __ Sltu(TMP, dst_low, (dst_low == rhs_low) ? lhs_low : rhs_low);
1262 __ Addu(dst_high, lhs_high, rhs_high);
1263 __ Addu(dst_high, dst_high, TMP);
1266 __ Sltu(TMP, lhs_low, rhs_low);
1267 __ Subu(dst_low, lhs_low, rhs_low);
1268 __ Subu(dst_high, lhs_high, rhs_high);
1269 __ Subu(dst_high, dst_high, TMP);
1278 __ Ori(dst_low, lhs_low, low);
1281 __ LoadConst32(TMP, low);
1282 __ Or(dst_low, lhs_low, TMP);
1286 __ Ori(dst_high, lhs_high, high);
1290 __ LoadConst32(TMP, high);
1292 __ Or(dst_high, lhs_high, TMP);
1299 __ Xori(dst_low, lhs_low, low);
1302 __ LoadConst32(TMP, low);
1303 __ Xor(dst_low, lhs_low, TMP);
1307 __ Xori(dst_high, lhs_high, high);
1311 __ LoadConst32(TMP, high);
1313 __ Xor(dst_high, lhs_high, TMP);
1319 __ Andi(dst_low, lhs_low, low);
1321 __ LoadConst32(TMP, low);
1322 __ And(dst_low, lhs_low, TMP);
1324 __ Move(dst_low, lhs_low);
1327 __ Andi(dst_high, lhs_high, high);
1330 __ LoadConst32(TMP, high);
1332 __ And(dst_high, lhs_high, TMP);
1334 __ Move(dst_high, lhs_high);
1346 __ Addiu(dst_low, lhs_low, low);
1349 __ Sltiu(AT, dst_low, low);
1352 __ LoadConst32(TMP, low);
1353 __ Addu(dst_low, lhs_low, TMP);
1354 __ Sltu(AT, dst_low, TMP);
1358 __ Addiu(dst_high, lhs_high, high);
1362 __ LoadConst32(TMP, high);
1364 __ Addu(dst_high, lhs_high, TMP);
1367 __ Addu(dst_high, dst_high, AT);
1381 __ AddS(dst, lhs, rhs);
1383 __ AddD(dst, lhs, rhs);
1388 __ SubS(dst, lhs, rhs);
1390 __ SubD(dst, lhs, rhs);
1446 __ Move(dst, lhs);
1449 __ Sll(dst, lhs, shift_value);
1451 __ Sra(dst, lhs, shift_value);
1453 __ Srl(dst, lhs, shift_value);
1456 __ Rotr(dst, lhs, shift_value);
1458 __ Sll(TMP, lhs, (kMipsBitsPerWord - shift_value) & shift_mask);
1459 __ Srl(dst, lhs, shift_value);
1460 __ Or(dst, dst, TMP);
1465 __ Sllv(dst, lhs, rhs_reg);
1467 __ Srav(dst, lhs, rhs_reg);
1469 __ Srlv(dst, lhs, rhs_reg);
1472 __ Rotrv(dst, lhs, rhs_reg);
1474 __ Subu(TMP, ZERO, rhs_reg);
1480 __ Sllv(TMP, lhs, TMP);
1481 __ Srlv(dst, lhs, rhs_reg);
1482 __ Or(dst, dst, TMP);
1500 __ Srl(dst_high, lhs_low, kMipsBitsPerWord - shift_value);
1501 __ Ins(dst_high, lhs_high, shift_value, kMipsBitsPerWord - shift_value);
1502 __ Sll(dst_low, lhs_low, shift_value);
1504 __ Srl(dst_low, lhs_low, shift_value);
1505 __ Ins(dst_low, lhs_high, kMipsBitsPerWord - shift_value, shift_value);
1506 __ Sra(dst_high, lhs_high, shift_value);
1508 __ Srl(dst_low, lhs_low, shift_value);
1509 __ Ins(dst_low, lhs_high, kMipsBitsPerWord - shift_value, shift_value);
1510 __ Srl(dst_high, lhs_high, shift_value);
1512 __ Srl(dst_low, lhs_low, shift_value);
1513 __ Ins(dst_low, lhs_high, kMipsBitsPerWord - shift_value, shift_value);
1514 __ Srl(dst_high, lhs_high, shift_value);
1515 __ Ins(dst_high, lhs_low, kMipsBitsPerWord - shift_value, shift_value);
1519 __ Sll(dst_low, lhs_low, shift_value);
1520 __ Srl(TMP, lhs_low, kMipsBitsPerWord - shift_value);
1521 __ Sll(dst_high, lhs_high, shift_value);
1522 __ Or(dst_high, dst_high, TMP);
1524 __ Sra(dst_high, lhs_high, shift_value);
1525 __ Sll(TMP, lhs_high, kMipsBitsPerWord - shift_value);
1526 __ Srl(dst_low, lhs_low, shift_value);
1527 __ Or(dst_low, dst_low, TMP);
1529 __ Srl(dst_high, lhs_high, shift_value);
1530 __ Sll(TMP, lhs_high, kMipsBitsPerWord - shift_value);
1531 __ Srl(dst_low, lhs_low, shift_value);
1532 __ Or(dst_low, dst_low, TMP);
1534 __ Srl(TMP, lhs_low, shift_value);
1535 __ Sll(dst_low, lhs_high, kMipsBitsPerWord - shift_value);
1536 __ Or(dst_low, dst_low, TMP);
1537 __ Srl(TMP, lhs_high, shift_value);
1538 __ Sll(dst_high, lhs_low, kMipsBitsPerWord - shift_value);
1539 __ Or(dst_high, dst_high, TMP);
1545 __ Sll(dst_high, lhs_low, shift_value_high);
1546 __ Move(dst_low, ZERO);
1548 __ Sra(dst_low, lhs_high, shift_value_high);
1549 __ Sra(dst_high, dst_low, kMipsBitsPerWord - 1);
1551 __ Srl(dst_low, lhs_high, shift_value_high);
1552 __ Move(dst_high, ZERO);
1556 __ Move(dst_low, lhs_high);
1557 __ Move(dst_high, lhs_low);
1560 __ Srl(dst_low, lhs_high, shift_value_high);
1561 __ Ins(dst_low, lhs_low, kMipsBitsPerWord - shift_value_high, shift_value_high);
1562 __ Srl(dst_high, lhs_low, shift_value_high);
1563 __ Ins(dst_high, lhs_high, kMipsBitsPerWord - shift_value_high, shift_value_high);
1565 __ Sll(TMP, lhs_low, kMipsBitsPerWord - shift_value_high);
1566 __ Srl(dst_low, lhs_high, shift_value_high);
1567 __ Or(dst_low, dst_low, TMP);
1568 __ Sll(TMP, lhs_high, kMipsBitsPerWord - shift_value_high);
1569 __ Srl(dst_high, lhs_low, shift_value_high);
1570 __ Or(dst_high, dst_high, TMP);
1578 __ Sllv(dst_low, lhs_low, rhs_reg);
1579 __ Nor(AT, ZERO, rhs_reg);
1580 __ Srl(TMP, lhs_low, 1);
1581 __ Srlv(TMP, TMP, AT);
1582 __ Sllv(dst_high, lhs_high, rhs_reg);
1583 __ Or(dst_high, dst_high, TMP);
1584 __ Andi(TMP, rhs_reg, kMipsBitsPerWord);
1585 __ Beqz(TMP, &done);
1586 __ Move(dst_high, dst_low);
1587 __ Move(dst_low, ZERO);
1589 __ Srav(dst_high, lhs_high, rhs_reg);
1590 __ Nor(AT, ZERO, rhs_reg);
1591 __ Sll(TMP, lhs_high, 1);
1592 __ Sllv(TMP, TMP, AT);
1593 __ Srlv(dst_low, lhs_low, rhs_reg);
1594 __ Or(dst_low, dst_low, TMP);
1595 __ Andi(TMP, rhs_reg, kMipsBitsPerWord);
1596 __ Beqz(TMP, &done);
1597 __ Move(dst_low, dst_high);
1598 __ Sra(dst_high, dst_high, 31);
1600 __ Srlv(dst_high, lhs_high, rhs_reg);
1601 __ Nor(AT, ZERO, rhs_reg);
1602 __ Sll(TMP, lhs_high, 1);
1603 __ Sllv(TMP, TMP, AT);
1604 __ Srlv(dst_low, lhs_low, rhs_reg);
1605 __ Or(dst_low, dst_low, TMP);
1606 __ Andi(TMP, rhs_reg, kMipsBitsPerWord);
1607 __ Beqz(TMP, &done);
1608 __ Move(dst_low, dst_high);
1609 __ Move(dst_high, ZERO);
1611 __ Nor(AT, ZERO, rhs_reg);
1612 __ Srlv(TMP, lhs_low, rhs_reg);
1613 __ Sll(dst_low, lhs_high, 1);
1614 __ Sllv(dst_low, dst_low, AT);
1615 __ Or(dst_low, dst_low, TMP);
1616 __ Srlv(TMP, lhs_high, rhs_reg);
1617 __ Sll(dst_high, lhs_low, 1);
1618 __ Sllv(dst_high, dst_high, AT);
1619 __ Or(dst_high, dst_high, TMP);
1620 __ Andi(TMP, rhs_reg, kMipsBitsPerWord);
1621 __ Beqz(TMP, &done);
1622 __ Move(TMP, dst_high);
1623 __ Move(dst_high, dst_low);
1624 __ Move(dst_low, TMP);
1626 __ Bind(&done);
1677 __ LoadFromOffset(kLoadUnsignedByte, out, obj, offset);
1679 __ Addu(TMP, obj, index.AsRegister<Register>());
1680 __ LoadFromOffset(kLoadUnsignedByte, out, TMP, data_offset);
1691 __ LoadFromOffset(kLoadSignedByte, out, obj, offset);
1693 __ Addu(TMP, obj, index.AsRegister<Register>());
1694 __ LoadFromOffset(kLoadSignedByte, out, TMP, data_offset);
1705 __ LoadFromOffset(kLoadSignedHalfword, out, obj, offset);
1707 __ Sll(TMP, index.AsRegister<Register>(), TIMES_2);
1708 __ Addu(TMP, obj, TMP);
1709 __ LoadFromOffset(kLoadSignedHalfword, out, TMP, data_offset);
1720 __ LoadFromOffset(kLoadUnsignedHalfword, out, obj, offset);
1722 __ Sll(TMP, index.AsRegister<Register>(), TIMES_2);
1723 __ Addu(TMP, obj, TMP);
1724 __ LoadFromOffset(kLoadUnsignedHalfword, out, TMP, data_offset);
1737 __ LoadFromOffset(kLoadWord, out, obj, offset);
1739 __ Sll(TMP, index.AsRegister<Register>(), TIMES_4);
1740 __ Addu(TMP, obj, TMP);
1741 __ LoadFromOffset(kLoadWord, out, TMP, data_offset);
1752 __ LoadFromOffset(kLoadDoubleword, out, obj, offset);
1754 __ Sll(TMP, index.AsRegister<Register>(), TIMES_8);
1755 __ Addu(TMP, obj, TMP);
1756 __ LoadFromOffset(kLoadDoubleword, out, TMP, data_offset);
1767 __ LoadSFromOffset(out, obj, offset);
1769 __ Sll(TMP, index.AsRegister<Register>(), TIMES_4);
1770 __ Addu(TMP, obj, TMP);
1771 __ LoadSFromOffset(out, TMP, data_offset);
1782 __ LoadDFromOffset(out, obj, offset);
1784 __ Sll(TMP, index.AsRegister<Register>(), TIMES_8);
1785 __ Addu(TMP, obj, TMP);
1786 __ LoadDFromOffset(out, TMP, data_offset);
1809 __ LoadFromOffset(kLoadWord, out, obj, offset);
1851 __ StoreToOffset(kStoreByte, value, obj, offset);
1853 __ Addu(TMP, obj, index.AsRegister<Register>());
1854 __ StoreToOffset(kStoreByte, value, TMP, data_offset);
1866 __ StoreToOffset(kStoreHalfword, value, obj, offset);
1868 __ Sll(TMP, index.AsRegister<Register>(), TIMES_2);
1869 __ Addu(TMP, obj, TMP);
1870 __ StoreToOffset(kStoreHalfword, value, TMP, data_offset);
1883 __ StoreToOffset(kStoreWord, value, obj, offset);
1886 __ Sll(TMP, index.AsRegister<Register>(), TIMES_4);
1887 __ Addu(TMP, obj, TMP);
1888 __ StoreToOffset(kStoreWord, value, TMP, data_offset);
1913 __ StoreToOffset(kStoreDoubleword, value, obj, offset);
1915 __ Sll(TMP, index.AsRegister<Register>(), TIMES_8);
1916 __ Addu(TMP, obj, TMP);
1917 __ StoreToOffset(kStoreDoubleword, value, TMP, data_offset);
1929 __ StoreSToOffset(value, obj, offset);
1931 __ Sll(TMP, index.AsRegister<Register>(), TIMES_4);
1932 __ Addu(TMP, obj, TMP);
1933 __ StoreSToOffset(value, TMP, data_offset);
1945 __ StoreDToOffset(value, obj, offset);
1947 __ Sll(TMP, index.AsRegister<Register>(), TIMES_8);
1948 __ Addu(TMP, obj, TMP);
1949 __ StoreDToOffset(value, TMP, data_offset);
1989 __ Bgeu(index, length, slow_path->GetEntryLabel());
2012 __ Beqz(obj, slow_path->GetExitLabel());
2014 __ LoadFromOffset(kLoadWord, obj_cls, obj, mirror::Object::ClassOffset().Int32Value());
2015 __ Bne(obj_cls, cls, slow_path->GetEntryLabel());
2016 __ Bind(slow_path->GetExitLabel());
2088 __ Slt(TMP, lhs, rhs);
2089 __ Slt(res, rhs, lhs);
2090 __ Subu(res, res, TMP);
2100 __ Slt(TMP, lhs_high, rhs_high);
2101 __ Slt(AT, rhs_high, lhs_high); // Inverted: is actually gt.
2102 __ Subu(res, AT, TMP); // Result -1:1:0 for [ <, >, == ].
2103 __ Bnez(res, &done); // If we compared ==, check if lower bits are also equal.
2104 __ Sltu(TMP, lhs_low, rhs_low);
2105 __ Sltu(AT, rhs_low, lhs_low); // Inverted: is actually gt.
2106 __ Subu(res, AT, TMP); // Result -1:1:0 for [ <, >, == ].
2107 __ Bind(&done);
2117 __ CmpEqS(FTMP, lhs, rhs);
2118 __ LoadConst32(res, 0);
2119 __ Bc1nez(FTMP, &done);
2121 __ CmpLtS(FTMP, lhs, rhs);
2122 __ LoadConst32(res, -1);
2123 __ Bc1nez(FTMP, &done);
2124 __ LoadConst32(res, 1);
2126 __ CmpLtS(FTMP, rhs, lhs);
2127 __ LoadConst32(res, 1);
2128 __ Bc1nez(FTMP, &done);
2129 __ LoadConst32(res, -1);
2133 __ ColtS(0, lhs, rhs);
2134 __ LoadConst32(res, -1);
2135 __ Bc1t(0, &done);
2136 __ CeqS(0, lhs, rhs);
2137 __ LoadConst32(res, 1);
2138 __ Movt(res, ZERO, 0);
2140 __ ColtS(0, rhs, lhs);
2141 __ LoadConst32(res, 1);
2142 __ Bc1t(0, &done);
2143 __ CeqS(0, lhs, rhs);
2144 __ LoadConst32(res, -1);
2145 __ Movt(res, ZERO, 0);
2148 __ Bind(&done);
2157 __ CmpEqD(FTMP, lhs, rhs);
2158 __ LoadConst32(res, 0);
2159 __ Bc1nez(FTMP, &done);
2161 __ CmpLtD(FTMP, lhs, rhs);
2162 __ LoadConst32(res, -1);
2163 __ Bc1nez(FTMP, &done);
2164 __ LoadConst32(res, 1);
2166 __ CmpLtD(FTMP, rhs, lhs);
2167 __ LoadConst32(res, 1);
2168 __ Bc1nez(FTMP, &done);
2169 __ LoadConst32(res, -1);
2173 __ ColtD(0, lhs, rhs);
2174 __ LoadConst32(res, -1);
2175 __ Bc1t(0, &done);
2176 __ CeqD(0, lhs, rhs);
2177 __ LoadConst32(res, 1);
2178 __ Movt(res, ZERO, 0);
2180 __ ColtD(0, rhs, lhs);
2181 __ LoadConst32(res, 1);
2182 __ Bc1t(0, &done);
2183 __ CeqD(0, lhs, rhs);
2184 __ LoadConst32(res, -1);
2185 __ Movt(res, ZERO, 0);
2188 __ Bind(&done);
2253 __ LoadConst32(dst, 0);
2254 __ B(&done);
2257 __ Bind(&true_label);
2258 __ LoadConst32(dst, 1);
2259 __ Bind(&done);
2276 __ Move(out, ZERO);
2279 __ Subu(out, ZERO, dividend);
2281 __ Move(out, dividend);
2303 __ Srl(TMP, dividend, 31);
2305 __ Sra(TMP, dividend, 31);
2306 __ Srl(TMP, TMP, 32 - ctz_imm);
2308 __ Addu(out, dividend, TMP);
2309 __ Sra(out, out, ctz_imm);
2311 __ Subu(out, ZERO, out);
2316 __ Sra(TMP, dividend, 31);
2317 __ Subu(out, dividend, TMP);
2318 __ Andi(out, out, 1);
2319 __ Addu(out, out, TMP);
2321 __ Sra(TMP, dividend, 31);
2322 __ Srl(TMP, TMP, 32 - ctz_imm);
2323 __ Addu(out, dividend, TMP);
2325 __ Andi(out, out, abs_imm - 1);
2327 __ Sll(out, out, 32 - ctz_imm);
2328 __ Srl(out, out, 32 - ctz_imm);
2330 __ Subu(out, out, TMP);
2353 __ LoadConst32(TMP, magic);
2355 __ MuhR6(TMP, dividend, TMP);
2357 __ MultR2(dividend, TMP);
2358 __ Mfhi(TMP);
2361 __ Addu(TMP, TMP, dividend);
2363 __ Subu(TMP, TMP, dividend);
2367 __ Sra(TMP, TMP, shift);
2371 __ Sra(out, TMP, 31);
2372 __ Subu(out, TMP, out);
2374 __ Sra(AT, TMP, 31);
2375 __ Subu(AT, TMP, AT);
2376 __ LoadConst32(TMP, imm);
2378 __ MulR6(TMP, AT, TMP);
2380 __ MulR2(TMP, AT, TMP);
2382 __ Subu(out, dividend, TMP);
2412 __ DivR6(out, dividend, divisor);
2414 __ DivR2(out, dividend, divisor);
2418 __ ModR6(out, dividend, divisor);
2420 __ ModR2(out, dividend, divisor);
2486 __ DivS(dst, lhs, rhs);
2488 __ DivD(dst, lhs, rhs);
2522 __ B(slow_path->GetEntryLabel());
2529 __ Beqz(value.AsRegister<Register>(), slow_path->GetEntryLabel());
2536 __ B(slow_path->GetEntryLabel());
2543 __ Or(TMP, value.AsRegisterPairHigh<Register>(), value.AsRegisterPairLow<Register>());
2544 __ Beqz(TMP, slow_path->GetEntryLabel());
2599 __ B(codegen_->GetLabelOf(successor));
2636 __ Xori(dst, lhs, rhs_imm);
2640 __ LoadConst32(rhs_reg, rhs_imm);
2642 __ Xor(dst, lhs, rhs_reg);
2645 __ Sltiu(dst, dst, 1);
2647 __ Sltu(dst, ZERO, dst);
2654 __ Slti(dst, lhs, rhs_imm);
2658 __ LoadConst32(rhs_reg, rhs_imm);
2660 __ Slt(dst, lhs, rhs_reg);
2665 __ Xori(dst, dst, 1);
2673 __ Slti(dst, lhs, rhs_imm + 1);
2677 __ Xori(dst, dst, 1);
2682 __ LoadConst32(rhs_reg, rhs_imm);
2684 __ Slt(dst, rhs_reg, lhs);
2688 __ Xori(dst, dst, 1);
2700 __ Sltiu(dst, lhs, rhs_imm);
2704 __ LoadConst32(rhs_reg, rhs_imm);
2706 __ Sltu(dst, lhs, rhs_reg);
2711 __ Xori(dst, dst, 1);
2725 __ Sltiu(dst, lhs, rhs_imm + 1);
2729 __ Xori(dst, dst, 1);
2734 __ LoadConst32(rhs_reg, rhs_imm);
2736 __ Sltu(dst, rhs_reg, lhs);
2740 __ Xori(dst, dst, 1);
2765 __ Beqz(lhs, label);
2769 __ Bnez(lhs, label);
2772 __ Bltz(lhs, label);
2775 __ Bgez(lhs, label);
2778 __ Blez(lhs, label);
2781 __ Bgtz(lhs, label);
2786 __ B(label);
2793 __ LoadConst32(rhs_reg, rhs_imm);
2797 __ Beq(lhs, rhs_reg, label);
2800 __ Bne(lhs, rhs_reg, label);
2803 __ Blt(lhs, rhs_reg, label);
2806 __ Bge(lhs, rhs_reg, label);
2809 __ Bge(rhs_reg, lhs, label);
2812 __ Blt(rhs_reg, lhs, label);
2815 __ Bltu(lhs, rhs_reg, label);
2818 __ Bgeu(lhs, rhs_reg, label);
2821 __ Bgeu(rhs_reg, lhs, label);
2824 __ Bltu(rhs_reg, lhs, label);
2855 __ Or(TMP, lhs_high, lhs_low);
2856 __ Beqz(TMP, label);
2860 __ Or(TMP, lhs_high, lhs_low);
2861 __ Bnez(TMP, label);
2864 __ Bltz(lhs_high, label);
2867 __ Bgez(lhs_high, label);
2870 __ Or(TMP, lhs_high, lhs_low);
2871 __ Sra(AT, lhs_high, 31);
2872 __ Bgeu(AT, TMP, label);
2875 __ Or(TMP, lhs_high, lhs_low);
2876 __ Sra(AT, lhs_high, 31);
2877 __ Bltu(AT, TMP, label);
2882 __ B(label);
2889 __ LoadConst32(TMP, imm_high);
2890 __ Xor(TMP, TMP, lhs_high);
2891 __ LoadConst32(AT, imm_low);
2892 __ Xor(AT, AT, lhs_low);
2893 __ Or(TMP, TMP, AT);
2894 __ Beqz(TMP, label);
2897 __ LoadConst32(TMP, imm_high);
2898 __ Xor(TMP, TMP, lhs_high);
2899 __ LoadConst32(AT, imm_low);
2900 __ Xor(AT, AT, lhs_low);
2901 __ Or(TMP, TMP, AT);
2902 __ Bnez(TMP, label);
2905 __ LoadConst32(TMP, imm_high);
2906 __ Blt(lhs_high, TMP, label);
2907 __ Slt(TMP, TMP, lhs_high);
2908 __ LoadConst32(AT, imm_low);
2909 __ Sltu(AT, lhs_low, AT);
2910 __ Blt(TMP, AT, label);
2913 __ LoadConst32(TMP, imm_high);
2914 __ Blt(TMP, lhs_high, label);
2915 __ Slt(TMP, lhs_high, TMP);
2916 __ LoadConst32(AT, imm_low);
2917 __ Sltu(AT, lhs_low, AT);
2918 __ Or(TMP, TMP, AT);
2919 __ Beqz(TMP, label);
2922 __ LoadConst32(TMP, imm_high);
2923 __ Blt(lhs_high, TMP, label);
2924 __ Slt(TMP, TMP, lhs_high);
2925 __ LoadConst32(AT, imm_low);
2926 __ Sltu(AT, AT, lhs_low);
2927 __ Or(TMP, TMP, AT);
2928 __ Beqz(TMP, label);
2931 __ LoadConst32(TMP, imm_high);
2932 __ Blt(TMP, lhs_high, label);
2933 __ Slt(TMP, lhs_high, TMP);
2934 __ LoadConst32(AT, imm_low);
2935 __ Sltu(AT, AT, lhs_low);
2936 __ Blt(TMP, AT, label);
2939 __ LoadConst32(TMP, imm_high);
2940 __ Bltu(lhs_high, TMP, label);
2941 __ Sltu(TMP, TMP, lhs_high);
2942 __ LoadConst32(AT, imm_low);
2943 __ Sltu(AT, lhs_low, AT);
2944 __ Blt(TMP, AT, label);
2947 __ LoadConst32(TMP, imm_high);
2948 __ Bltu(TMP, lhs_high, label);
2949 __ Sltu(TMP, lhs_high, TMP);
2950 __ LoadConst32(AT, imm_low);
2951 __ Sltu(AT, lhs_low, AT);
2952 __ Or(TMP, TMP, AT);
2953 __ Beqz(TMP, label);
2956 __ LoadConst32(TMP, imm_high);
2957 __ Bltu(lhs_high, TMP, label);
2958 __ Sltu(TMP, TMP, lhs_high);
2959 __ LoadConst32(AT, imm_low);
2960 __ Sltu(AT, AT, lhs_low);
2961 __ Or(TMP, TMP, AT);
2962 __ Beqz(TMP, label);
2965 __ LoadConst32(TMP, imm_high);
2966 __ Bltu(TMP, lhs_high, label);
2967 __ Sltu(TMP, lhs_high, TMP);
2968 __ LoadConst32(AT, imm_low);
2969 __ Sltu(AT, AT, lhs_low);
2970 __ Blt(TMP, AT, label);
2976 __ Xor(TMP, lhs_high, rhs_high);
2977 __ Xor(AT, lhs_low, rhs_low);
2978 __ Or(TMP, TMP, AT);
2979 __ Beqz(TMP, label);
2982 __ Xor(TMP, lhs_high, rhs_high);
2983 __ Xor(AT, lhs_low, rhs_low);
2984 __ Or(TMP, TMP, AT);
2985 __ Bnez(TMP, label);
2988 __ Blt(lhs_high, rhs_high, label);
2989 __ Slt(TMP, rhs_high, lhs_high);
2990 __ Sltu(AT, lhs_low, rhs_low);
2991 __ Blt(TMP, AT, label);
2994 __ Blt(rhs_high, lhs_high, label);
2995 __ Slt(TMP, lhs_high, rhs_high);
2996 __ Sltu(AT, lhs_low, rhs_low);
2997 __ Or(TMP, TMP, AT);
2998 __ Beqz(TMP, label);
3001 __ Blt(lhs_high, rhs_high, label);
3002 __ Slt(TMP, rhs_high, lhs_high);
3003 __ Sltu(AT, rhs_low, lhs_low);
3004 __ Or(TMP, TMP, AT);
3005 __ Beqz(TMP, label);
3008 __ Blt(rhs_high, lhs_high, label);
3009 __ Slt(TMP, lhs_high, rhs_high);
3010 __ Sltu(AT, rhs_low, lhs_low);
3011 __ Blt(TMP, AT, label);
3014 __ Bltu(lhs_high, rhs_high, label);
3015 __ Sltu(TMP, rhs_high, lhs_high);
3016 __ Sltu(AT, lhs_low, rhs_low);
3017 __ Blt(TMP, AT, label);
3020 __ Bltu(rhs_high, lhs_high, label);
3021 __ Sltu(TMP, lhs_high, rhs_high);
3022 __ Sltu(AT, lhs_low, rhs_low);
3023 __ Or(TMP, TMP, AT);
3024 __ Beqz(TMP, label);
3027 __ Bltu(lhs_high, rhs_high, label);
3028 __ Sltu(TMP, rhs_high, lhs_high);
3029 __ Sltu(AT, rhs_low, lhs_low);
3030 __ Or(TMP, TMP, AT);
3031 __ Beqz(TMP, label);
3034 __ Bltu(rhs_high, lhs_high, label);
3035 __ Sltu(TMP, lhs_high, rhs_high);
3036 __ Sltu(AT, rhs_low, lhs_low);
3037 __ Blt(TMP, AT, label);
3055 __ CmpEqS(FTMP, lhs, rhs);
3056 __ Bc1nez(FTMP, label);
3059 __ CmpEqS(FTMP, lhs, rhs);
3060 __ Bc1eqz(FTMP, label);
3064 __ CmpLtS(FTMP, lhs, rhs);
3066 __ CmpUltS(FTMP, lhs, rhs);
3068 __ Bc1nez(FTMP, label);
3072 __ CmpLeS(FTMP, lhs, rhs);
3074 __ CmpUleS(FTMP, lhs, rhs);
3076 __ Bc1nez(FTMP, label);
3080 __ CmpUltS(FTMP, rhs, lhs);
3082 __ CmpLtS(FTMP, rhs, lhs);
3084 __ Bc1nez(FTMP, label);
3088 __ CmpUleS(FTMP, rhs, lhs);
3090 __ CmpLeS(FTMP, rhs, lhs);
3092 __ Bc1nez(FTMP, label);
3100 __ CeqS(0, lhs, rhs);
3101 __ Bc1t(0, label);
3104 __ CeqS(0, lhs, rhs);
3105 __ Bc1f(0, label);
3109 __ ColtS(0, lhs, rhs);
3111 __ CultS(0, lhs, rhs);
3113 __ Bc1t(0, label);
3117 __ ColeS(0, lhs, rhs);
3119 __ CuleS(0, lhs, rhs);
3121 __ Bc1t(0, label);
3125 __ CultS(0, rhs, lhs);
3127 __ ColtS(0, rhs, lhs);
3129 __ Bc1t(0, label);
3133 __ CuleS(0, rhs, lhs);
3135 __ ColeS(0, rhs, lhs);
3137 __ Bc1t(0, label);
3148 __ CmpEqD(FTMP, lhs, rhs);
3149 __ Bc1nez(FTMP, label);
3152 __ CmpEqD(FTMP, lhs, rhs);
3153 __ Bc1eqz(FTMP, label);
3157 __ CmpLtD(FTMP, lhs, rhs);
3159 __ CmpUltD(FTMP, lhs, rhs);
3161 __ Bc1nez(FTMP, label);
3165 __ CmpLeD(FTMP, lhs, rhs);
3167 __ CmpUleD(FTMP, lhs, rhs);
3169 __ Bc1nez(FTMP, label);
3173 __ CmpUltD(FTMP, rhs, lhs);
3175 __ CmpLtD(FTMP, rhs, lhs);
3177 __ Bc1nez(FTMP, label);
3181 __ CmpUleD(FTMP, rhs, lhs);
3183 __ CmpLeD(FTMP, rhs, lhs);
3185 __ Bc1nez(FTMP, label);
3193 __ CeqD(0, lhs, rhs);
3194 __ Bc1t(0, label);
3197 __ CeqD(0, lhs, rhs);
3198 __ Bc1f(0, label);
3202 __ ColtD(0, lhs, rhs);
3204 __ CultD(0, lhs, rhs);
3206 __ Bc1t(0, label);
3210 __ ColeD(0, lhs, rhs);
3212 __ CuleD(0, lhs, rhs);
3214 __ Bc1t(0, label);
3218 __ CultD(0, rhs, lhs);
3220 __ ColtD(0, rhs, lhs);
3222 __ Bc1t(0, label);
3226 __ CuleD(0, rhs, lhs);
3228 __ ColeD(0, rhs, lhs);
3230 __ Bc1t(0, label);
3252 __ B(true_target);
3257 __ B(false_target);
3276 __ Beqz(cond_val.AsRegister<Register>(), false_target);
3278 __ Bnez(cond_val.AsRegister<Register>(), true_target);
3311 __ B(false_target);
3372 __ Bind(&false_target);
3384 __ Nop();
3456 __ Addiu32(locations->GetTemp(0).AsRegister<Register>(), obj, offset);
3458 __ Lw(ZERO, locations->GetTemp(0).AsRegister<Register>(), 0);
3468 __ Mtc1(locations->GetTemp(1).AsRegister<Register>(),
3470 __ MoveToFpuHigh(locations->GetTemp(2).AsRegister<Register>(),
3481 __ LoadFromOffset(kLoadWord, dst_high, obj, offset + kMipsWordSize);
3483 __ LoadFromOffset(kLoadWord, dst, obj, offset);
3485 __ LoadFromOffset(kLoadWord, dst, obj, offset);
3487 __ LoadFromOffset(kLoadWord, dst_high, obj, offset + kMipsWordSize);
3492 __ LoadFromOffset(load_type, dst, obj, offset);
3498 __ LoadSFromOffset(dst, obj, offset);
3500 __ LoadDFromOffset(dst, obj, offset);
3583 __ Addiu32(locations->GetTemp(0).AsRegister<Register>(), obj, offset);
3585 __ Lw(ZERO, locations->GetTemp(0).AsRegister<Register>(), 0);
3589 __ Mfc1(locations->GetTemp(1).AsRegister<Register>(),
3591 __ MoveFromFpuHigh(locations->GetTemp(2).AsRegister<Register>(),
3607 __ StoreToOffset(kStoreWord, src, obj, offset);
3609 __ StoreToOffset(kStoreWord, src_high, obj, offset + kMipsWordSize);
3613 __ StoreToOffset(store_type, src, obj, offset);
3619 __ StoreSToOffset(src, obj, offset);
3621 __ StoreDToOffset(src, obj, offset);
3679 __ Move(out, ZERO);
3680 __ Beqz(obj, &done);
3683 __ LoadFromOffset(kLoadWord, out, obj, mirror::Object::ClassOffset().Int32Value());
3686 __ Xor(out, out, cls);
3687 __ Sltiu(out, out, 1);
3693 __ Bne(out, cls, slow_path->GetEntryLabel());
3694 __ LoadConst32(out, 1);
3695 __ Bind(slow_path->GetExitLabel());
3698 __ Bind(&done);
3739 __ LoadConst32(invoke->GetLocations()->GetTemp(1).AsRegister<Register>(),
3744 __ LoadFromOffset(kLoadWord, temp, SP, receiver.GetStackIndex());
3745 __ LoadFromOffset(kLoadWord, temp, temp, class_offset);
3747 __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset);
3750 __ LoadFromOffset(kLoadWord, temp, temp,
3755 __ LoadFromOffset(kLoadWord, temp, temp, method_offset);
3757 __ LoadFromOffset(kLoadWord, T9, temp, entry_point.Int32Value());
3759 __ Jalr(T9);
3760 __ Nop();
3840 __ LoadFromOffset(kLoadWord,
3849 __ LoadConst32(temp.AsRegister<Register>(), invoke->GetMethodAddress());
3868 __ Lw(reg, SP, kCurrentMethodStackOffset);
3872 __ LoadFromOffset(kLoadWord,
3879 __ LoadFromOffset(kLoadWord,
3889 __ Jalr(&frame_entry_label_, T9);
3893 __ LoadConst32(T9, invoke->GetDirectCodePtr());
3895 __ Jalr(T9);
3896 __ Nop();
3906 __ LoadFromOffset(kLoadWord,
3912 __ Jalr(T9);
3913 __ Nop();
3947 __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset);
3950 __ LoadFromOffset(kLoadWord, temp, temp, method_offset);
3952 __ LoadFromOffset(kLoadWord, T9, temp, entry_point.Int32Value());
3954 __ Jalr(T9);
3955 __ Nop();
3994 __ LoadFromOffset(kLoadWord, out, current_method,
3997 __ LoadFromOffset(kLoadWord, out, current_method,
3999 __ LoadFromOffset(kLoadWord, out, out, CodeGenerator::GetCacheOffset(cls->GetTypeIndex()));
4010 __ Beqz(out, slow_path->GetEntryLabel());
4015 __ Bind(slow_path->GetExitLabel());
4033 __ LoadFromOffset(kLoadWord, out, TR, GetExceptionTlsOffset());
4041 __ StoreToOffset(kStoreWord, ZERO, TR, GetExceptionTlsOffset());
4057 __ LoadFromOffset(kLoadWord, out, current_method, ArtMethod::DeclaringClassOffset().Int32Value());
4058 __ LoadFromOffset(kLoadWord, out, out, mirror::Class::DexCacheStringsOffset().Int32Value());
4059 __ LoadFromOffset(kLoadWord, out, out, CodeGenerator::GetCacheOffset(load->GetStringIndex()));
4064 __ Beqz(out, slow_path->GetEntryLabel());
4065 __ Bind(slow_path->GetExitLabel());
4138 __ MulR6(dst, lhs, rhs);
4140 __ MulR2(dst, lhs, rhs);
4164 __ MulR6(TMP, lhs_high, rhs_low);
4165 __ MulR6(dst_high, lhs_low, rhs_high);
4166 __ Addu(dst_high, dst_high, TMP);
4167 __ MuhuR6(TMP, lhs_low, rhs_low);
4168 __ Addu(dst_high, dst_high, TMP);
4169 __ MulR6(dst_low, lhs_low, rhs_low);
4171 __ MulR2(TMP, lhs_high, rhs_low);
4172 __ MulR2(dst_high, lhs_low, rhs_high);
4173 __ Addu(dst_high, dst_high, TMP);
4174 __ MultuR2(lhs_low, rhs_low);
4175 __ Mfhi(TMP);
4176 __ Addu(dst_high, dst_high, TMP);
4177 __ Mflo(dst_low);
4187 __ MulS(dst, lhs, rhs);
4189 __ MulD(dst, lhs, rhs);
4227 __ Subu(dst, ZERO, src);
4235 __ Subu(dst_low, ZERO, src_low);
4236 __ Sltu(TMP, ZERO, dst_low);
4237 __ Subu(dst_high, ZERO, src_high);
4238 __ Subu(dst_high, dst_high, TMP);
4246 __ NegS(dst, src);
4248 __ NegD(dst, src);
4270 __ Lw(current_method_register, SP, kCurrentMethodStackOffset);
4272 __ LoadConst32(calling_convention.GetRegisterAt(0), instruction->GetTypeIndex());
4301 __ LoadFromOffset(kLoadWord, temp, TR, QUICK_ENTRY_POINT(pNewEmptyString));
4302 __ LoadFromOffset(kLoadWord, T9, temp, code_offset.Int32Value());
4303 __ Jalr(T9);
4304 __ Nop();
4331 __ Nor(dst, src, ZERO);
4340 __ Nor(dst_high, src_high, ZERO);
4341 __ Nor(dst_low, src_low, ZERO);
4358 __ Xori(locations->Out().AsRegister<Register>(),
4380 __ Lw(ZERO, obj.AsRegister<Register>(), 0);
4390 __ Beqz(obj.AsRegister<Register>(), slow_path->GetEntryLabel());
4768 __ Move(dst_low, src);
4769 __ Sra(dst_high, src, 31);
4778 __ Andi(dst, src, 0xFFFF);
4782 __ Seb(dst, src);
4784 __ Sll(dst, src, 24);
4785 __ Sra(dst, dst, 24);
4790 __ Seh(dst, src);
4792 __ Sll(dst, src, 16);
4793 __ Sra(dst, dst, 16);
4797 __ Move(dst, src);
4812 __ Mtc1(src_low, FTMP);
4813 __ Mthc1(src_high, FTMP);
4815 __ Cvtsl(dst, FTMP);
4817 __ Cvtdl(dst, FTMP);
4838 __ Mtc1(src, FTMP);
4840 __ Cvtsw(dst, FTMP);
4842 __ Cvtdw(dst, FTMP);
4884 __ LoadConst32(TMP, min_val);
4885 __ Mtc1(TMP, FTMP);
4886 __ CmpLeS(FTMP, FTMP, src);
4889 __ LoadConst32(TMP, High32Bits(min_val));
4890 __ Mtc1(ZERO, FTMP);
4891 __ Mthc1(TMP, FTMP);
4892 __ CmpLeD(FTMP, FTMP, src);
4895 __ Bc1nez(FTMP, &truncate);
4898 __ CmpEqS(FTMP, src, src);
4900 __ CmpEqD(FTMP, src, src);
4902 __ Move(dst_low, ZERO);
4903 __ LoadConst32(dst_high, std::numeric_limits<int32_t>::min());
4904 __ Mfc1(TMP, FTMP);
4905 __ And(dst_high, dst_high, TMP);
4907 __ B(&done);
4909 __ Bind(&truncate);
4912 __ TruncLS(FTMP, src);
4914 __ TruncLD(FTMP, src);
4916 __ Mfc1(dst_low, FTMP);
4917 __ Mfhc1(dst_high, FTMP);
4919 __ Bind(&done);
4948 __ LoadConst32(TMP, min_val);
4949 __ Mtc1(TMP, FTMP);
4952 __ LoadConst32(TMP, High32Bits(min_val));
4953 __ Mtc1(ZERO, FTMP);
4955 __ Mtc1(TMP, static_cast<FRegister>(FTMP + 1));
4957 __ Mthc1(TMP, FTMP);
4963 __ CmpLeS(FTMP, FTMP, src);
4965 __ CmpLeD(FTMP, FTMP, src);
4967 __ Bc1nez(FTMP, &truncate);
4970 __ CmpEqS(FTMP, src, src);
4972 __ CmpEqD(FTMP, src, src);
4974 __ LoadConst32(dst, std::numeric_limits<int32_t>::min());
4975 __ Mfc1(TMP, FTMP);
4976 __ And(dst, dst, TMP);
4979 __ ColeS(0, FTMP, src);
4981 __ ColeD(0, FTMP, src);
4983 __ Bc1t(0, &truncate);
4986 __ CeqS(0, src, src);
4988 __ CeqD(0, src, src);
4990 __ LoadConst32(dst, std::numeric_limits<int32_t>::min());
4991 __ Movf(dst, ZERO, 0);
4994 __ B(&done);
4996 __ Bind(&truncate);
4999 __ TruncWS(FTMP, src);
5001 __ TruncWD(FTMP, src);
5003 __ Mfc1(dst, FTMP);
5005 __ Bind(&done);
5012 __ Cvtsd(dst, src);
5014 __ Cvtds(dst, src);
5143 __ Addiu32(temp_reg, value_reg, -lower_bound);
5147 __ Bltz(temp_reg, codegen_->GetLabelOf(default_block));
5151 __ Beqz(temp_reg, codegen_->GetLabelOf(successors[0]));
5154 __ Addiu(temp_reg, temp_reg, -2);
5156 __ Bltz(temp_reg, codegen_->GetLabelOf(successors[last_index + 1]));
5158 __ Beqz(temp_reg, codegen_->GetLabelOf(successors[last_index + 2]));
5162 __ Addiu(temp_reg, temp_reg, -1);
5163 __ Beqz(temp_reg, codegen_->GetLabelOf(successors[last_index + 1]));
5168 __ B(codegen_->GetLabelOf(default_block));
5195 __ LoadFromOffset(kLoadWord,
5202 __ LoadFromOffset(kLoadWord,
5206 __ LoadFromOffset(kLoadWord,
5213 #undef __