Lines Matching defs:offset
35 uint32_t offset = encoding_ & kOffset12Mask;
36 ASSERT(offset < 256);
38 ((offset & 0xf0) << 4) | (offset & 0xf);
47 uint32_t offset = encoding_ & kOffset12Mask;
48 ASSERT(offset < (1 << 10)); // In the range 0 to +1020.
49 ASSERT(Utils::IsAligned(offset, 4)); // Multiple of 4.
51 ASSERT((mode == Offset) || (mode == NegOffset));
52 uint32_t vencoding = (encoding_ & (0xf << kRnShift)) | (offset >> 2);
53 if (mode == Offset) {
98 void Assembler::EmitType5(Condition cond, int32_t offset, bool link) {
103 Emit(Assembler::EncodeBranchOffset(offset, encoding));
518 void Assembler::ldrd(Register rd, Register rn, int32_t offset, Condition cond) {
522 ldr(rd, Address(rn, offset), cond);
523 ldr(rd2, Address(rn, offset + kWordSize), cond);
525 EmitMemOpAddressMode3(cond, B7 | B6 | B4, rd, Address(rn, offset));
530 void Assembler::strd(Register rd, Register rn, int32_t offset, Condition cond) {
534 str(rd, Address(rn, offset), cond);
535 str(rd2, Address(rn, offset + kWordSize), cond);
537 EmitMemOpAddressMode3(cond, B7 | B6 | B5 | B4, rd, Address(rn, offset));
1535 int32_t offset,
1541 if (Address::CanHoldLoadOffset(kWord, offset, &offset_mask)) {
1542 ldr(rd, Address(pp, offset), cond);
1544 int32_t offset_hi = offset & ~offset_mask; // signed
1545 uint32_t offset_lo = offset & offset_mask; // unsigned
1568 const intptr_t offset = CodeSize() + Instr::kPCReadOffset +
1571 AddImmediate(R0, R0, -offset);
1631 const int32_t offset = ObjectPool::element_offset(
1634 LoadWordFromPoolOffset(rd, offset - kHeapObjectTag, pp, cond);
1660 const int32_t offset =
1662 LoadWordFromPoolOffset(dst, offset - kHeapObjectTag, new_pp, AL);
1670 const int32_t offset = ObjectPool::element_offset(
1672 LoadWordFromPoolOffset(rd, offset - kHeapObjectTag, PP, cond);
1725 Operand offset;
1726 if (!Operand::CanHold(VerifiedMemory::offset(), &offset)) {
1727 FATAL1("Offset 0x%" Px " not representable", VerifiedMemory::offset());
1729 return offset;
1734 intptr_t offset,
1741 str(value, Address(base, offset), cond);
1744 str(value, Address(base, offset), cond);
1749 intptr_t offset,
1759 strd(value_even, base, offset, cond);
1762 strd(value_even, base, offset, cond);
1787 ASSERT(address.mode() == Address::Offset ||
1886 int32_t offset,
1890 if (Address::CanHoldStoreOffset(kWord, offset - kHeapObjectTag, &ignored)) {
1892 object, FieldAddress(object, offset), value, can_value_be_smi);
1894 AddImmediate(IP, object, offset - kHeapObjectTag);
1916 int32_t offset,
1920 if (Address::CanHoldStoreOffset(kWord, offset - kHeapObjectTag, &ignored)) {
1921 StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value,
1924 AddImmediate(IP, object, offset - kHeapObjectTag);
1943 int32_t offset,
1947 if (Address::CanHoldStoreOffset(kWord, offset - kHeapObjectTag, &ignored)) {
1948 StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value,
1951 AddImmediate(IP, object, offset - kHeapObjectTag);
2032 const intptr_t offset =
2034 LoadFromOffset(kWord, result, result, offset);
2109 static bool CanEncodeBranchOffset(int32_t offset) {
2110 ASSERT(Utils::IsAligned(offset, 4));
2111 // Note: This check doesn't take advantage of the fact that offset>>2
2113 return Utils::IsInt(Utils::CountOneBits(kBranchOffsetMask), offset);
2117 int32_t Assembler::EncodeBranchOffset(int32_t offset, int32_t inst) {
2118 // The offset is off by 8 due to the way the ARM CPUs read PC.
2119 offset -= Instr::kPCReadOffset;
2121 if (!CanEncodeBranchOffset(offset)) {
2128 offset >>= 2;
2129 offset &= kBranchOffsetMask;
2130 return (inst & ~kBranchOffsetMask) | offset;
2141 int32_t offset = 0;
2142 offset |= (movt & 0xf0000) << 12;
2143 offset |= (movt & 0xfff) << 16;
2144 offset |= (movw & 0xf0000) >> 4;
2145 offset |= movw & 0xfff;
2146 return offset;
2152 int32_t offset = 0;
2153 offset |= (mov & 0xff) << 24;
2154 offset |= (or1 & 0xff) << 16;
2155 offset |= (or2 & 0xff) << 8;
2156 offset |= (or3 & 0xff);
2157 return offset;
2187 const int32_t offset = DecodeARMv6LoadImmediate(mov, or1, or2, or3);
2188 const int32_t dest = region.start() + offset;
2205 // If the offset loading instructions aren't there, we must have replaced
2222 const int32_t offset = DecodeARMv7LoadImmediate(movt, movw);
2223 const int32_t dest = region.start() + offset;
2236 // If the offset loading instructions aren't there, we must have replaced
2247 void Assembler::EmitFarBranch(Condition cond, int32_t offset, bool link) {
2249 LoadPatchableImmediate(IP, offset);
2272 // Use the offset field of the branch instruction for linking the sites.
2287 // Far branches are enabled and we can't encode the branch offset.
2289 // Grab instructions that load the offset.
2318 // Grab instructions that load the offset, and the branch.
2334 // Encode the branch and the offset.
2371 // Far branches are enabled and we can't encode the branch offset.
2373 // Grab instructions that load the offset.
2394 // Far branches are enabled, but we can encode the branch offset.
2396 // Grab instructions that load the offset, and the branch.
2408 // Encode the branch and the offset.
2493 int32_t offset,
2501 return Utils::IsAbsoluteUint(8, offset); // Addressing mode 3.
2507 return Utils::IsAbsoluteUint(12, offset); // Addressing mode 2.
2513 return (Utils::IsAbsoluteUint(10, offset) && Utils::IsAligned(offset, 4));
2517 return offset == 0;
2528 int32_t offset,
2535 return Utils::IsAbsoluteUint(8, offset); // Addressing mode 3.
2542 return Utils::IsAbsoluteUint(12, offset); // Addressing mode 2.
2548 return (Utils::IsAbsoluteUint(10, offset) && Utils::IsAligned(offset, 4));
2552 return offset == 0;
2563 bool is_load, intptr_t cid, int64_t offset) {
2566 return CanHoldLoadOffset(OperandSizeFor(cid), offset, &offset_mask);
2568 return CanHoldStoreOffset(OperandSizeFor(cid), offset, &offset_mask);
2748 const int32_t offset = ObjectPool::element_offset(
2750 LoadWordFromPoolOffset(CODE_REG, offset - kHeapObjectTag, pp, cond);
2761 const int32_t offset = ObjectPool::element_offset(
2763 LoadWordFromPoolOffset(CODE_REG, offset - kHeapObjectTag, PP, AL);
2792 void Assembler::BranchLinkOffset(Register base, int32_t offset) {
2795 LoadFromOffset(kWord, IP, base, offset);
2828 const int32_t offset = Array::element_offset(FindImmediate(value));
2829 LoadWordFromPoolOffset(rd, offset - kHeapObjectTag, PP, cond);
2886 int32_t offset,
2889 if (!Address::CanHoldLoadOffset(size, offset, &offset_mask)) {
2891 AddImmediate(IP, base, offset & ~offset_mask, cond);
2893 offset = offset & offset_mask;
2897 ldrsb(reg, Address(base, offset), cond);
2900 ldrb(reg, Address(base, offset), cond);
2903 ldrsh(reg, Address(base, offset), cond);
2906 ldrh(reg, Address(base, offset), cond);
2909 ldr(reg, Address(base, offset), cond);
2912 ldrd(reg, base, offset, cond);
2923 int32_t offset,
2926 if (!Address::CanHoldStoreOffset(size, offset, &offset_mask)) {
2929 AddImmediate(IP, base, offset & ~offset_mask, cond);
2931 offset = offset & offset_mask;
2935 strb(reg, Address(base, offset), cond);
2938 strh(reg, Address(base, offset), cond);
2941 str(reg, Address(base, offset), cond);
2944 strd(reg, base, offset, cond);
2954 int32_t offset,
2957 if (!Address::CanHoldLoadOffset(kSWord, offset, &offset_mask)) {
2959 offset & ~offset_mask, cond);
2961 offset = offset & offset_mask;
2963 vldrs(reg, Address(base, offset), cond);
2969 int32_t offset,
2972 if (!Address::CanHoldStoreOffset(kSWord, offset, &offset_mask)) {
2974 AddImmediate(IP, base, offset & ~offset_mask, cond);
2976 offset = offset & offset_mask;
2978 vstrs(reg, Address(base, offset), cond);
2984 int32_t offset,
2987 if (!Address::CanHoldLoadOffset(kDWord, offset, &offset_mask)) {
2989 AddImmediate(IP, base, offset & ~offset_mask, cond);
2991 offset = offset & offset_mask;
2993 vldrd(reg, Address(base, offset), cond);
2999 int32_t offset,
3002 if (!Address::CanHoldStoreOffset(kDWord, offset, &offset_mask)) {
3004 AddImmediate(IP, base, offset & ~offset_mask, cond);
3006 offset = offset & offset_mask;
3008 vstrd(reg, Address(base, offset), cond);
3015 int32_t offset) {
3017 AddImmediate(IP, base, offset);
3024 int32_t offset) {
3026 AddImmediate(IP, base, offset);
3618 const int64_t offset = offset_base +
3620 ASSERT(Utils::IsInt(32, offset));
3622 if (Address::CanHoldImmediateOffset(is_load, cid, offset)) {
3623 return Address(array, static_cast<int32_t>(offset));
3625 ASSERT(Address::CanHoldImmediateOffset(is_load, cid, offset - offset_base));
3627 return Address(temp, static_cast<int32_t>(offset - offset_base));
3640 int32_t offset =
3646 if ((offset != 0) ||
3664 offset,
3667 offset,
3669 AddImmediate(base, offset & ~offset_mask);
3670 offset = offset & offset_mask;
3672 return Address(base, offset);
