Lines Matching refs:imm32
1158 (result, carry, overflow) = AddWithCarry(SP, imm32, '0');
1178 uint32_t imm32;
1182 imm32 = Bits32(opcode, 7, 0) << 2; // imm32 = ZeroExtend(imm8:'00', 32)
1186 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
1191 addr_t sp_offset = imm32;
1372 result = imm32;
1387 uint32_t imm32; // the immediate value to be written to Rd
1397 imm32 = Bits32(opcode, 7, 0); // imm32 = ZeroExtend(imm8, 32)
1405 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry);
1412 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:i:imm3:imm8,
1420 imm32 = (imm4 << 12) | (i << 11) | (imm3 << 8) | imm8;
1428 // d = UInt(Rd); setflags = (S == '1'); (imm32, carry) =
1432 imm32 = ARMExpandImm_C(opcode, APSR_C, carry);
1442 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:imm12, 32);
1447 imm32 = (imm4 << 12) | imm12;
1457 uint32_t result = imm32;
1614 result = NOT(imm32);
1629 uint32_t imm32; // the output after ThumbExpandImm_C or ARMExpandImm_C
1636 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry);
1641 imm32 = ARMExpandImm_C(opcode, APSR_C, carry);
1651 uint32_t result = ~imm32;
1756 address = if add then (base + imm32) else (base - imm32);
1784 uint32_t imm32; // immediate offset from the PC
1785 bool add; // +imm32 or -imm32?
1792 imm32 = Bits32(opcode, 7, 0) << 2; // imm32 = ZeroExtend(imm8:'00', 32);
1797 imm32 = Bits32(opcode, 11, 0) << 2; // imm32 = ZeroExtend(imm12, 32);
1808 address = base + imm32;
1810 address = base - imm32;
1843 (result, carry, overflow) = AddWithCarry(SP, imm32, '0');
1862 uint32_t imm32; // the immediate operand
1867 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm8:'00', 32);
1869 imm32 = (Bits32(opcode, 7, 0) << 2);
1874 // d = 13; setflags = FALSE; imm32 = ZeroExtend(imm7:'00', 32);
1876 imm32 = ThumbImm7Scaled(opcode); // imm32 = ZeroExtend(imm7:'00', 32)
1881 // d = UInt(Rd); setflags = (S == "1"); imm32 =
1884 imm32 = ThumbExpandImm(opcode);
1898 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(i:imm3:imm8, 32);
1904 imm32 = (i << 11) | (imm3 << 8) | imm8;
1914 // (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
1915 AddWithCarryResult res = AddWithCarry(sp, imm32, 0);
2020 targetAddress = Align(PC,4) + imm32;
2022 targetAddress = PC + imm32;
2038 int32_t imm32; // PC-relative offset
2051 imm32 = llvm::SignExtend32<25>(imm25);
2052 target = pc + imm32;
2054 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2070 imm32 = llvm::SignExtend32<25>(imm25);
2071 target = Align(pc, 4) + imm32;
2073 context.SetISAAndImmediateSigned(eModeARM, 4 + imm32);
2080 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2);
2081 target = Align(pc, 4) + imm32;
2083 context.SetISAAndImmediateSigned(eModeARM, 8 + imm32);
2087 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2 |
2089 target = pc + imm32;
2091 context.SetISAAndImmediateSigned(eModeThumb, 8 + imm32);
2285 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
2303 uint32_t imm32;
2306 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2311 addr_t ip_offset = imm32;
2335 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
2353 uint32_t imm32;
2356 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2361 addr_t sp_offset = imm32;
2388 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
2409 uint32_t imm32;
2414 imm32 = ThumbImm7Scaled(opcode); // imm32 = ZeroExtend(imm7:'00', 32)
2419 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
2428 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
2435 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2445 AddWithCarryResult res = AddWithCarry(sp, ~imm32, 1);
2449 uint64_t imm64 = imm32; // Need to expand it to 64 bits before attempting
2474 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
2568 address = SP - imm32;
2569 SP = SP - imm32;
2591 uint32_t imm32; // stack offset
2598 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2609 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2620 addr_t sp_offset = imm32;
2662 SP = SP + imm32;
2683 uint32_t imm32; // stack offset
2690 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2701 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2712 addr_t sp_offset = imm32;
2763 uint32_t imm32; // the immediate constant
2768 imm32 = Bits32(opcode, 7, 0);
2773 imm32 = Bits32(opcode, 23, 0);
2782 context.SetISAAndImmediate(mode, imm32);
2817 BranchWritePC(PC + imm32);
2830 int32_t imm32; // PC-relative offset
2834 imm32 = llvm::SignExtend32<9>(Bits32(opcode, 7, 0) << 1);
2835 target = pc + imm32;
2836 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2839 imm32 = llvm::SignExtend32<12>(Bits32(opcode, 10, 0) << 1);
2840 target = pc + imm32;
2841 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2857 imm32 = llvm::SignExtend32<21>(imm21);
2858 target = pc + imm32;
2859 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2872 imm32 = llvm::SignExtend32<25>(imm25);
2873 target = pc + imm32;
2874 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2878 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2);
2879 target = pc + imm32;
2880 context.SetISAAndImmediateSigned(eModeARM, 8 + imm32);
2900 BranchWritePC(PC + imm32);
2917 uint32_t imm32; // PC-relative offset to branch forward
2921 imm32 = Bit32(opcode, 9) << 6 | Bits32(opcode, 7, 3) << 1;
2923 target = pc + imm32;
2924 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
3027 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3042 uint32_t imm32;
3048 // d = UInt(Rd); n = UInt(Rn); setflags = !InITBlock(); imm32 =
3053 imm32 = Bits32(opcode, 8, 6);
3058 // d = UInt(Rdn); n = UInt(Rdn); setflags = !InITBlock(); imm32 =
3063 imm32 = Bits32(opcode, 7, 0);
3069 // d = UInt(Rd); n = UInt(Rn); setflags = (S == '1'); imm32 =
3074 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry_out);
3088 // d = UInt(Rd); n = UInt(Rn); setflags = FALSE; imm32 =
3096 imm32 = (i << 11) | (imm3 << 8) | imm8;
3118 //(result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3119 AddWithCarryResult res = AddWithCarry(Rn, imm32, 0);
3126 context.SetRegisterPlusOffset(reg_n, imm32);
3150 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3167 imm32; // the immediate value to be added to the value obtained from Rn
3174 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
3185 AddWithCarryResult res = AddWithCarry(val1, imm32, 0);
3197 context.SetRegisterPlusOffset(dwarf_reg, imm32);
3304 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3314 uint32_t imm32; // the immediate value to be compared with
3318 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
3324 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
3334 AddWithCarryResult res = AddWithCarry(reg_val, imm32, 0);
3417 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
3427 uint32_t imm32; // the immediate value to be compared with
3431 imm32 = Bits32(opcode, 7, 0);
3435 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
3441 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
3451 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
4436 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
4453 uint32_t imm32; // the immediate offset used to form the address
4462 imm32 = Bits32(opcode, 10, 6) << 2; // imm32 = ZeroExtend(imm5:'00', 32);
4471 // t = UInt(Rt); n = 13; imm32 = ZeroExtend(imm8:'00', 32);
4474 imm32 = Bits32(opcode, 7, 0) << 2;
4485 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
4488 imm32 = Bits32(opcode, 11, 0);
4510 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
4513 imm32 = Bits32(opcode, 7, 0);
4535 offset_addr = base + imm32;
4537 offset_addr = base - imm32;
5142 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5158 uint32_t imm32;
5165 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5:'00', 32);
5168 imm32 = Bits32(opcode, 10, 6) << 2;
5177 // t = UInt(Rt); n = 13; imm32 = ZeroExtend(imm8:'00', 32);
5180 imm32 = Bits32(opcode, 7, 0) << 2;
5193 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
5196 imm32 = Bits32(opcode, 11, 0);
5217 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
5220 imm32 = Bits32(opcode, 7, 0);
5239 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5245 offset_addr = base_address + imm32;
5247 offset_addr = base_address - imm32;
5499 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5510 uint32_t imm32;
5517 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5, 32);
5520 imm32 = Bits32(opcode, 10, 6);
5533 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
5536 imm32 = Bits32(opcode, 11, 0);
5554 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
5557 imm32 = Bits32(opcode, 7, 0);
5580 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5582 offset_addr = base_address + imm32;
5584 offset_addr = base_address - imm32;
5815 (result, carry, overflow) = AddWithCarry(R[n], imm32, APSR.C);
5832 imm32; // the immediate value to be added to the value obtained from Rn
5839 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
5847 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
5861 AddWithCarryResult res = AddWithCarry(val1, imm32, APSR_C);
5969 result = if add then (Align(PC,4) + imm32) else (Align(PC,4) - imm32);
5980 uint32_t imm32; // the immediate value to be added/subtracted to/from the PC
5985 imm32 = ThumbImm8Scaled(opcode); // imm32 = ZeroExtend(imm8:'00', 32)
5991 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
5999 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
6011 uint32_t result = (add ? Align(pc, 4) + imm32 : Align(pc, 4) - imm32);
6032 result = R[n] AND imm32;
6049 imm32; // the immediate value to be ANDed to the value obtained from Rn
6057 imm32 = ThumbExpandImm_C(
6059 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
6070 imm32 =
6072 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
6086 uint32_t result = val1 & imm32;
6197 result = R[n] AND NOT(imm32);
6213 uint32_t imm32; // the immediate value to be bitwise inverted and ANDed to
6222 imm32 = ThumbExpandImm_C(
6224 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
6232 imm32 =
6234 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
6250 uint32_t result = val1 & ~imm32;
6360 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6379 uint32_t imm32;
6390 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6393 imm32 = Bits32(opcode, 11, 0);
6417 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6419 offset_addr = base_address + imm32;
6421 offset_addr = base_address - imm32;
6704 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6715 uint32_t imm32;
6723 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5, 32);
6726 imm32 = Bits32(opcode, 10, 6);
6736 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6739 imm32 = Bits32(opcode, 11, 0);
6766 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
6769 imm32 = Bits32(opcode, 7, 0);
6802 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6804 offset_addr = Rn + imm32;
6806 offset_addr = Rn - imm32;
6852 address = if add then (base + imm32) else (base - imm32);
6860 uint32_t imm32;
6864 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6866 imm32 = Bits32(opcode, 11, 0);
6880 // t == UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6882 imm32 = Bits32(opcode, 11, 0);
6902 // address = if add then (base + imm32) else (base - imm32);
6904 address = base + imm32;
6906 address = base - imm32;
7094 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7109 uint32_t imm32;
7117 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5:'0', 32);
7120 imm32 = Bits32(opcode, 10, 6) << 1;
7132 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7135 imm32 = Bits32(opcode, 11, 0);
7156 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7159 imm32 = Bits32(opcode, 7, 0);
7175 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7185 offset_addr = Rn + imm32;
7187 offset_addr = Rn - imm32;
7242 address = if add then (base + imm32) else (base - imm32);
7254 uint32_t imm32;
7261 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
7263 imm32 = Bits32(opcode, 11, 0);
7276 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
7278 imm32 = (imm4H << 4) | imm4L;
7299 // address = if add then (base + imm32) else (base - imm32);
7301 address = base + imm32;
7303 address = base - imm32;
7521 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7532 uint32_t imm32;
7542 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7545 imm32 = Bits32(opcode, 11, 0);
7566 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7569 imm32 = Bits32(opcode, 7, 0);
7588 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
7594 imm32 = (imm4H << 4) | imm4L;
7620 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7622 offset_addr = Rn + imm32;
7624 offset_addr = Rn - imm32;
7671 address = if add then (base + imm32) else (base - imm32);
7679 uint32_t imm32;
7686 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
7688 imm32 = Bits32(opcode, 11, 0);
7698 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
7702 imm32 = (imm4H << 4) | imm4L;
7722 // address = if add then (base + imm32) else (base - imm32);
7725 address = base + imm32;
7727 address = base - imm32;
7918 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7933 uint32_t imm32;
7943 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7946 imm32 = Bits32(opcode, 11, 0);
7968 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7971 imm32 = Bits32(opcode, 7, 0);
7987 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
7992 imm32 = (imm4H << 4) | imm4L;
8011 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
8019 offset_addr = Rn + imm32;
8021 offset_addr = Rn - imm32;
8078 address = if add then (base + imm32) else (base - imm32);
8090 uint32_t imm32;
8097 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
8099 imm32 = Bits32(opcode, 11, 0);
8109 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
8113 imm32 = (imm4H << 4) | imm4L;
8134 // address = if add then (base + imm32) else (base - imm32);
8136 address = base + imm32;
8138 address = base - imm32;
8146 context.SetRegisterPlusOffset(base_reg, imm32);
8839 result = R[n] EOR imm32;
8856 imm32; // the immediate value to be ORed to the value obtained from Rn
8864 imm32 = ThumbExpandImm_C(
8866 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
8877 imm32 =
8879 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
8895 uint32_t result = val1 ^ imm32;
9008 result = R[n] OR imm32;
9025 imm32; // the immediate value to be ORed to the value obtained from Rn
9033 imm32 = ThumbExpandImm_C(
9035 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9046 imm32 =
9048 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9062 uint32_t result = val1 | imm32;
9173 (result, carry, overflow) = AddWithCarry(NOT(R[n]), imm32, '1');
9191 imm32; // the immediate value to be added to the value obtained from Rn
9197 imm32 = 0;
9203 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9211 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9226 AddWithCarryResult res = AddWithCarry(~reg_val, imm32, 1);
9324 (result, carry, overflow) = AddWithCarry(NOT(R[n]), imm32, APSR.C);
9342 imm32; // the immediate value to be added to the value obtained from Rn
9348 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9363 AddWithCarryResult res = AddWithCarry(~reg_val, imm32, APSR_C);
9453 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), APSR.C);
9471 imm32; // the immediate value to be added to the value obtained from Rn
9477 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9485 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9500 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, APSR_C);
9605 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
9619 uint32_t imm32; // the immediate value to be subtracted from the value
9626 imm32 = Bits32(opcode, 8, 6); // imm32 = ZeroExtend(imm3, 32)
9631 imm32 = Bits32(opcode, 7, 0); // imm32 = ZeroExtend(imm8, 32)
9637 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9655 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
9676 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
9695 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
9713 uint32_t imm32; // the immediate value to be subtracted from the value
9720 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9743 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
9753 int64_t imm32_signed = imm32;
9772 result = R[n] EOR imm32;
9784 imm32; // the immediate value to be ANDed to the value obtained from Rn
9789 imm32 = ThumbExpandImm_C(
9791 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9797 imm32 =
9799 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9810 uint32_t result = val1 ^ imm32;
9897 result = R[n] AND imm32;
9909 imm32; // the immediate value to be ANDed to the value obtained from Rn
9914 imm32 = ThumbExpandImm_C(
9916 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9922 imm32 =
9924 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9935 uint32_t result = val1 & imm32;
10353 address = R[n] + imm32;
10367 uint32_t imm32;
10372 // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 =
10378 imm32 = Bits32(opcode, 7, 0) << 2;
10391 // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = Zeros(32); // Zero
10396 imm32 = 0;
10412 // address = R[n] + imm32;
10417 addr_t address = Rn + imm32;
10425 context.SetRegisterToRegisterPlusOffset(data_reg, base_reg, imm32);
10464 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10475 uint32_t imm32;
10483 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
10486 imm32 = Bits32(opcode, 11, 0);
10507 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10514 offset_addr = Rn + imm32;
10516 offset_addr = Rn - imm32;
10557 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10568 uint32_t imm32;
10580 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
10583 imm32 = Bits32(opcode, 11, 0);
10600 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10607 offset_addr = Rn + imm32;
10609 offset_addr = Rn - imm32;
10666 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10679 uint32_t imm32;
10688 // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
10693 imm32 = Bits32(opcode, 7, 0) << 2;
10713 // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L,
10720 imm32 = (Bits32(opcode, 11, 8) << 4) | Bits32(opcode, 3, 0);
10745 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10752 offset_addr = Rn + imm32;
10754 offset_addr = Rn - imm32;
10943 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10956 uint32_t imm32;
10964 // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
10969 imm32 = Bits32(opcode, 7, 0) << 2;
10988 // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L,
10996 imm32 = (Bits32(opcode, 11, 8) << 4) | Bits32(opcode, 3, 0);
11028 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
11031 offset_addr = Rn + imm32;
11033 offset_addr = Rn - imm32;
11234 address = if add then R[n] else R[n]-imm32;
11235 if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11254 uint32_t imm32;
11274 // d = UInt(D:Vd); n = UInt(Rn); imm32 = ZeroExtend(imm8:'00', 32);
11277 imm32 = Bits32(opcode, 7, 0) << 2;
11312 // imm32 = ZeroExtend(imm8:'00', 32); regs = UInt(imm8);
11313 imm32 = Bits32(opcode, 7, 0) << 2;
11337 // address = if add then R[n] else R[n]-imm32;
11342 address = Rn - imm32;
11344 // if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11350 value = Rn + imm32;
11352 value = Rn - imm32;
11427 address = if add then R[n] else R[n]-imm32;
11428 if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11448 uint32_t imm32;
11468 // d = UInt(D:Vd); n = UInt(Rn); imm32 = ZeroExtend(imm8:'00', 32);
11471 imm32 = Bits32(opcode, 7, 0) << 2;
11506 // imm32 = ZeroExtend(imm8:'00', 32); regs = UInt(imm8);
11507 imm32 = Bits32(opcode, 7, 0) << 2;
11532 // address = if add then R[n] else R[n]-imm32;
11537 address = Rn - imm32;
11540 // if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11544 value = Rn + imm32;
11546 value = Rn - imm32;
11633 address = if add then (base + imm32) else (base - imm32);
11648 uint32_t imm32;
11655 // single_reg = FALSE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00',
11659 imm32 = Bits32(opcode, 7, 0) << 2;
11669 // single_reg = TRUE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00', 32);
11672 imm32 = Bits32(opcode, 7, 0) << 2;
11697 // address = if add then (base + imm32) else (base - imm32);
11700 address = base + imm32;
11702 address = base - imm32;
11759 address = if add then (R[n] + imm32) else (R[n] - imm32);
11774 uint32_t imm32;
11781 // single_reg = FALSE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00',
11785 imm32 = Bits32(opcode, 7, 0) << 2;
11799 // single_reg = TRUE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00', 32);
11802 imm32 = Bits32(opcode, 7, 0) << 2;
11825 // address = if add then (R[n] + imm32) else (R[n] - imm32);
11828 address = Rn + imm32;
11830 address = Rn - imm32;
12675 operand2 = if register_form then Shift(R[m], shift_t, shift_n, APSR.C) else imm32;
12698 uint32_t imm32;
12707 // imm32 = ZeroExtend(imm8, 32); register_form = FALSE; opcode = '0010';
12710 imm32 = Bits32(opcode, 7, 0);
12721 // n = UInt(Rn); imm32 = ARMExpandImm(imm12); register_form = FALSE;
12723 imm32 = ARMExpandImm(opcode);
12745 // else imm32;
12756 operand2 = imm32;