Lines Matching defs:imm32
598 (result, carry, overflow) = AddWithCarry(SP, imm32, '0');
619 uint32_t imm32;
623 imm32 = Bits32(opcode, 7, 0) << 2; // imm32 = ZeroExtend(imm8:'00', 32)
627 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
632 addr_t sp_offset = imm32;
808 result = imm32;
824 uint32_t imm32; // the immediate value to be written to Rd
833 imm32 = Bits32(opcode, 7, 0); // imm32 = ZeroExtend(imm8, 32)
841 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry);
849 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:i:imm3:imm8, 32);
856 imm32 = (imm4 << 12) | (i << 11) | (imm3 << 8) | imm8;
865 // d = UInt(Rd); setflags = (S == �1�); (imm32, carry) = ARMExpandImm_C(imm12, APSR.C);
868 imm32 = ARMExpandImm_C (opcode, APSR_C, carry);
878 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:imm12, 32);
883 imm32 = (imm4 << 12) | imm12;
894 uint32_t result = imm32;
1048 result = NOT(imm32);
1064 uint32_t imm32; // the output after ThumbExpandImm_C or ARMExpandImm_C
1071 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry);
1076 imm32 = ARMExpandImm_C(opcode, APSR_C, carry);
1085 uint32_t result = ~imm32;
1190 address = if add then (base + imm32) else (base - imm32);
1219 uint32_t imm32; // immediate offset from the PC
1220 bool add; // +imm32 or -imm32?
1227 imm32 = Bits32(opcode, 7, 0) << 2; // imm32 = ZeroExtend(imm8:'00', 32);
1232 imm32 = Bits32(opcode, 11, 0) << 2; // imm32 = ZeroExtend(imm12, 32);
1243 address = base + imm32;
1245 address = base - imm32;
1285 (result, carry, overflow) = AddWithCarry(SP, imm32, '0');
1305 uint32_t imm32; // the immediate operand
1311 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm8:'00', 32);
1313 imm32 = (Bits32 (opcode, 7, 0) << 2);
1318 // d = 13; setflags = FALSE; imm32 = ZeroExtend(imm7:'00', 32);
1320 imm32 = ThumbImm7Scaled(opcode); // imm32 = ZeroExtend(imm7:'00', 32)
1327 addr_t sp_offset = imm32;
1436 targetAddress = Align(PC,4) + imm32;
1438 targetAddress = PC + imm32;
1455 int32_t imm32; // PC-relative offset
1468 imm32 = llvm::SignExtend32<25>(imm25);
1469 target = pc + imm32;
1470 context.SetISAAndImmediateSigned (eModeThumb, 4 + imm32);
1486 imm32 = llvm::SignExtend32<25>(imm25);
1487 target = Align(pc, 4) + imm32;
1488 context.SetISAAndImmediateSigned (eModeARM, 4 + imm32);
1495 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2);
1496 target = Align(pc, 4) + imm32;
1497 context.SetISAAndImmediateSigned (eModeARM, 8 + imm32);
1501 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2 | Bits32(opcode, 24, 24) << 1);
1502 target = pc + imm32;
1503 context.SetISAAndImmediateSigned (eModeThumb, 8 + imm32);
1695 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
1714 uint32_t imm32;
1717 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
1722 addr_t ip_offset = imm32;
1747 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
1766 uint32_t imm32;
1769 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
1774 addr_t sp_offset = imm32;
1801 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
1823 uint32_t imm32;
1828 imm32 = ThumbImm7Scaled(opcode); // imm32 = ZeroExtend(imm7:'00', 32)
1833 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
1842 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
1849 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
1858 AddWithCarryResult res = AddWithCarry(sp, ~imm32, 1);
1863 uint64_t imm64 = imm32; // Need to expand it to 64 bits before attempting to negate it, or the wrong
1889 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
1992 address = SP - imm32;
1993 SP = SP - imm32;
2016 uint32_t imm32; // stack offset
2023 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2034 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2045 addr_t sp_offset = imm32;
2090 SP = SP + imm32;
2112 uint32_t imm32; // stack offset
2119 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2130 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2141 addr_t sp_offset = imm32;
2196 uint32_t imm32; // the immediate constant
2201 imm32 = Bits32(opcode, 7, 0);
2206 imm32 = Bits32(opcode, 23, 0);
2215 context.SetISAAndImmediate (mode, imm32);
2252 BranchWritePC(PC + imm32);
2266 int32_t imm32; // PC-relative offset
2270 imm32 = llvm::SignExtend32<9>(Bits32(opcode, 7, 0) << 1);
2271 target = pc + imm32;
2272 context.SetISAAndImmediateSigned (eModeThumb, 4 + imm32);
2275 imm32 = llvm::SignExtend32<12>(Bits32(opcode, 10, 0));
2276 target = pc + imm32;
2277 context.SetISAAndImmediateSigned (eModeThumb, 4 + imm32);
2288 imm32 = llvm::SignExtend32<21>(imm21);
2289 target = pc + imm32;
2290 context.SetISAAndImmediateSigned (eModeThumb, 4 + imm32);
2303 imm32 = llvm::SignExtend32<25>(imm25);
2304 target = pc + imm32;
2305 context.SetISAAndImmediateSigned (eModeThumb, 4 + imm32);
2309 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2);
2310 target = pc + imm32;
2311 context.SetISAAndImmediateSigned (eModeARM, 8 + imm32);
2332 BranchWritePC(PC + imm32);
2349 uint32_t imm32; // PC-relative offset to branch forward
2353 imm32 = Bit32(opcode, 9) << 6 | Bits32(opcode, 7, 3) << 1;
2355 target = pc + imm32;
2356 context.SetISAAndImmediateSigned (eModeThumb, 4 + imm32);
2452 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
2468 uint32_t imm32;
2475 // d = UInt(Rd); n = UInt(Rn); setflags = !InITBlock(); imm32 = ZeroExtend(imm3, 32);
2479 imm32 = Bits32 (opcode, 8,6);
2484 // d = UInt(Rdn); n = UInt(Rdn); setflags = !InITBlock(); imm32 = ZeroExtend(imm8, 32);
2488 imm32 = Bits32 (opcode, 7, 0);
2495 // d = UInt(Rd); n = UInt(Rn); setflags = (S == '1'); imm32 = ThumbExpandImm(i:imm3:imm8);
2499 imm32 = ThumbExpandImm_C (opcode, APSR_C, carry_out);
2511 // d = UInt(Rd); n = UInt(Rn); setflags = FALSE; imm32 = ZeroExtend(i:imm3:imm8, 32);
2518 imm32 = (i << 11) | (imm3 << 8) | imm8;
2534 //(result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
2535 AddWithCarryResult res = AddWithCarry (Rn, imm32, 0);
2542 context.SetRegisterPlusOffset (reg_n, imm32);
2566 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
2583 uint32_t imm32; // the immediate value to be added to the value obtained from Rn
2591 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2602 AddWithCarryResult res = AddWithCarry(val1, imm32, 0);
2608 context.SetRegisterPlusOffset (dwarf_reg, imm32);
2716 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
2726 uint32_t imm32; // the immediate value to be compared with
2730 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
2736 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2746 AddWithCarryResult res = AddWithCarry(reg_val, imm32, 0);
2836 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
2846 uint32_t imm32; // the immediate value to be compared with
2850 imm32 = Bits32(opcode, 7, 0);
2854 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
2860 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2870 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
3861 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
3879 uint32_t imm32; // the immediate offset used to form the address
3888 imm32 = Bits32(opcode, 10, 6) << 2; // imm32 = ZeroExtend(imm5:'00', 32);
3897 // t = UInt(Rt); n = 13; imm32 = ZeroExtend(imm8:'00', 32);
3900 imm32 = Bits32 (opcode, 7, 0) << 2;
3911 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
3914 imm32 = Bits32 (opcode, 11, 0);
3935 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
3938 imm32 = Bits32 (opcode, 7, 0);
3958 offset_addr = base + imm32;
3960 offset_addr = base - imm32;
4571 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
4588 uint32_t imm32;
4596 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5:'00', 32);
4599 imm32 = Bits32 (opcode, 10, 6) << 2;
4608 // t = UInt(Rt); n = 13; imm32 = ZeroExtend(imm8:'00', 32);
4611 imm32 = Bits32 (opcode, 7, 0) << 2;
4624 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
4627 imm32 = Bits32 (opcode, 11, 0);
4647 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
4650 imm32 = Bits32 (opcode, 7, 0);
4669 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
4675 offset_addr = base_address + imm32;
4677 offset_addr = base_address - imm32;
4921 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
4934 uint32_t imm32;
4942 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5, 32);
4945 imm32 = Bits32 (opcode, 10, 6);
4958 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
4961 imm32 = Bits32 (opcode, 11, 0);
4979 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
4982 imm32 = Bits32 (opcode, 7, 0);
5004 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5006 offset_addr = base_address + imm32;
5008 offset_addr = base_address - imm32;
5239 (result, carry, overflow) = AddWithCarry(R[n], imm32, APSR.C);
5256 uint32_t imm32; // the immediate value to be added to the value obtained from Rn
5264 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
5272 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
5286 AddWithCarryResult res = AddWithCarry(val1, imm32, APSR_C);
5395 result = if add then (Align(PC,4) + imm32) else (Align(PC,4) - imm32);
5407 uint32_t imm32; // the immediate value to be added/subtracted to/from the PC
5413 imm32 = ThumbImm8Scaled(opcode); // imm32 = ZeroExtend(imm8:'00', 32)
5419 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
5427 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
5439 uint32_t result = (add ? Align(pc, 4) + imm32 : Align(pc, 4) - imm32);
5460 result = R[n] AND imm32;
5477 uint32_t imm32; // the immediate value to be ANDed to the value obtained from Rn
5486 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
5497 imm32 = ARMExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
5511 uint32_t result = val1 & imm32;
5625 result = R[n] AND NOT(imm32);
5642 uint32_t imm32; // the immediate value to be bitwise inverted and ANDed to the value obtained from Rn
5651 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
5659 imm32 = ARMExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
5674 uint32_t result = val1 & ~imm32;
5784 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5804 uint32_t imm32;
5815 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
5818 imm32 = Bits32 (opcode, 11, 0);
5841 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5843 offset_addr = base_address + imm32;
5845 offset_addr = base_address - imm32;
6135 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6147 uint32_t imm32;
6156 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5, 32);
6159 imm32 = Bits32 (opcode, 10, 6);
6171 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6174 imm32 = Bits32 (opcode, 11, 0);
6195 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
6198 imm32 = Bits32 (opcode, 7, 0);
6222 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6224 offset_addr = Rn + imm32;
6226 offset_addr = Rn - imm32;
6272 address = if add then (base + imm32) else (base - imm32);
6281 uint32_t imm32;
6287 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6289 imm32 = Bits32 (opcode, 11, 0);
6299 // t == UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6301 imm32 = Bits32 (opcode, 11, 0);
6321 // address = if add then (base + imm32) else (base - imm32);
6323 address = base + imm32;
6325 address = base - imm32;
6508 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6525 uint32_t imm32;
6534 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5:'0', 32);
6537 imm32 = Bits32 (opcode, 10, 6) << 1;
6549 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6552 imm32 = Bits32 (opcode, 11, 0);
6572 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
6575 imm32 = Bits32 (opcode, 7, 0);
6591 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6600 offset_addr = Rn + imm32;
6602 offset_addr = Rn - imm32;
6658 address = if add then (base + imm32) else (base - imm32);
6671 uint32_t imm32;
6679 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6681 imm32 = Bits32 (opcode, 11, 0);
6695 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
6697 imm32 = (imm4H << 4) | imm4L;
6718 // address = if add then (base + imm32) else (base - imm32);
6720 address = base + imm32;
6722 address = base - imm32;
6940 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6952 uint32_t imm32;
6963 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6966 imm32 = Bits32 (opcode, 11, 0);
6987 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
6990 imm32 = Bits32 (opcode, 7, 0);
7009 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
7015 imm32 = (imm4H << 4) | imm4L;
7040 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7042 offset_addr = Rn + imm32;
7044 offset_addr = Rn - imm32;
7090 address = if add then (base + imm32) else (base - imm32);
7099 uint32_t imm32;
7107 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
7109 imm32 = Bits32 (opcode, 11, 0);
7120 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
7124 imm32 = (imm4H << 4) | imm4L;
7144 // address = if add then (base + imm32) else (base - imm32);
7147 address = base + imm32;
7149 address = base - imm32;
7337 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7353 uint32_t imm32;
7364 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7367 imm32 = Bits32 (opcode, 11, 0);
7388 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7391 imm32 = Bits32 (opcode, 7, 0);
7408 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
7413 imm32 = (imm4H << 4) | imm4L;
7431 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7438 offset_addr = Rn + imm32;
7440 offset_addr = Rn - imm32;
7498 address = if add then (base + imm32) else (base - imm32);
7511 uint32_t imm32;
7519 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
7521 imm32 = Bits32 (opcode, 11, 0);
7532 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
7536 imm32 = (imm4H << 4) | imm4L;
7557 // address = if add then (base + imm32) else (base - imm32);
7559 address = base + imm32;
7561 address = base - imm32;
7569 context.SetRegisterPlusOffset (base_reg, imm32);
8259 result = R[n] EOR imm32;
8276 uint32_t imm32; // the immediate value to be ORed to the value obtained from Rn
8285 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
8296 imm32 = ARMExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
8311 uint32_t result = val1 ^ imm32;
8426 result = R[n] OR imm32;
8443 uint32_t imm32; // the immediate value to be ORed to the value obtained from Rn
8452 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
8463 imm32 = ARMExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
8477 uint32_t result = val1 | imm32;
8590 (result, carry, overflow) = AddWithCarry(NOT(R[n]), imm32, '1');
8607 uint32_t imm32; // the immediate value to be added to the value obtained from Rn
8613 imm32 = 0;
8619 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
8627 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
8641 AddWithCarryResult res = AddWithCarry(~reg_val, imm32, 1);
8742 (result, carry, overflow) = AddWithCarry(NOT(R[n]), imm32, APSR.C);
8759 uint32_t imm32; // the immediate value to be added to the value obtained from Rn
8765 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
8779 AddWithCarryResult res = AddWithCarry(~reg_val, imm32, APSR_C);
8871 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), APSR.C);
8888 uint32_t imm32; // the immediate value to be added to the value obtained from Rn
8894 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
8902 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
8916 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, APSR_C);
9023 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
9037 uint32_t imm32; // the immediate value to be subtracted from the value obtained from Rn
9043 imm32 = Bits32(opcode, 8, 6); // imm32 = ZeroExtend(imm3, 32)
9048 imm32 = Bits32(opcode, 7, 0); // imm32 = ZeroExtend(imm8, 32)
9054 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9072 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
9093 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
9114 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
9131 uint32_t imm32; // the immediate value to be subtracted from the value obtained from Rn
9137 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9159 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
9180 result = R[n] EOR imm32;
9192 uint32_t imm32; // the immediate value to be ANDed to the value obtained from Rn
9198 imm32 = ThumbExpandImm_C (opcode, APSR_C, carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9204 imm32 = ARMExpandImm_C (opcode, APSR_C, carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9215 uint32_t result = val1 ^ imm32;
9305 result = R[n] AND imm32;
9317 uint32_t imm32; // the immediate value to be ANDed to the value obtained from Rn
9323 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9329 imm32 = ARMExpandImm_C(opcode, APSR_C, carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9340 uint32_t result = val1 & imm32;
9757 address = R[n] + imm32;
9772 uint32_t imm32;
9778 // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8:�00�, 32);
9782 imm32 = Bits32 (opcode, 7, 0) << 2;
9795 // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = Zeros(32); // Zero offset
9799 imm32 = 0;
9815 // address = R[n] + imm32;
9820 addr_t address = Rn + imm32;
9828 context.SetRegisterToRegisterPlusOffset (data_reg, base_reg, imm32);
9864 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
9876 uint32_t imm32;
9885 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
9888 imm32 = Bits32 (opcode, 11, 0);
9909 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
9916 offset_addr = Rn + imm32;
9918 offset_addr = Rn - imm32;
9960 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
9972 uint32_t imm32;
9984 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
9987 imm32 = Bits32 (opcode, 11, 0);
10004 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10011 offset_addr = Rn + imm32;
10013 offset_addr = Rn - imm32;
10072 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10086 uint32_t imm32;
10096 //t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 = ZeroExtend(imm8:�00�, 32);
10100 imm32 = Bits32 (opcode, 7, 0) << 2;
10120 //t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
10126 imm32 = (Bits32 (opcode, 11, 8) << 4) | Bits32 (opcode, 3, 0);
10151 //offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10158 offset_addr = Rn + imm32;
10160 offset_addr = Rn - imm32;
10344 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10358 uint32_t imm32;
10367 // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 = ZeroExtend(imm8:�00�, 32);
10371 imm32 = Bits32 (opcode, 7, 0) << 2;
10390 // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
10397 imm32 = (Bits32 (opcode, 11, 8) << 4) | Bits32 (opcode, 3, 0);
10429 //offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10432 offset_addr = Rn + imm32;
10434 offset_addr = Rn - imm32;
10628 address = if add then R[n] else R[n]-imm32;
10629 if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
10648 uint32_t imm32;
10668 // d = UInt(D:Vd); n = UInt(Rn); imm32 = ZeroExtend(imm8:�00�, 32);
10671 imm32 = Bits32 (opcode, 7, 0) << 2;
10703 // imm32 = ZeroExtend(imm8:�00�, 32); regs = UInt(imm8);
10704 imm32 = Bits32 (opcode, 7, 0) << 2;
10727 // address = if add then R[n] else R[n]-imm32;
10732 address = Rn - imm32;
10734 // if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
10741 value = Rn + imm32;
10743 value = Rn - imm32;
10819 address = if add then R[n] else R[n]-imm32;
10820 if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
10840 uint32_t imm32;
10860 // d = UInt(D:Vd); n = UInt(Rn); imm32 = ZeroExtend(imm8:�00�, 32);
10863 imm32 = Bits32 (opcode, 7, 0) << 2;
10895 // imm32 = ZeroExtend(imm8:�00�, 32); regs = UInt(imm8);
10896 imm32 = Bits32 (opcode, 7, 0) << 2;
10920 // address = if add then R[n] else R[n]-imm32;
10925 address = Rn - imm32;
10928 // if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
10933 value = Rn + imm32;
10935 value = Rn - imm32;
11017 address = if add then (base + imm32) else (base - imm32);
11032 uint32_t imm32;
11040 // single_reg = FALSE; add = (U == �1�); imm32 = ZeroExtend(imm8:�00�, 32);
11043 imm32 = Bits32 (opcode, 7, 0) << 2;
11053 // single_reg = TRUE; add = (U == �1�); imm32 = ZeroExtend(imm8:�00�, 32);
11056 imm32 = Bits32 (opcode, 7, 0) << 2;
11081 // address = if add then (base + imm32) else (base - imm32);
11084 address = base + imm32;
11086 address = base - imm32;
11146 address = if add then (R[n] + imm32) else (R[n] - imm32);
11161 uint32_t imm32;
11169 // single_reg = FALSE; add = (U == �1�); imm32 = ZeroExtend(imm8:�00�, 32);
11172 imm32 = Bits32 (opcode, 7, 0) << 2;
11186 // single_reg = TRUE; add = (U == �1�); imm32 = ZeroExtend(imm8:�00�, 32);
11189 imm32 = Bits32 (opcode, 7, 0) << 2;
11212 // address = if add then (R[n] + imm32) else (R[n] - imm32);
11215 address = Rn + imm32;
11217 address = Rn - imm32;
12080 operand2 = if register_form then Shift(R[m], shift_t, shift_n, APSR.C) else imm32;
12104 uint32_t imm32;
12114 // n = 14; imm32 = ZeroExtend(imm8, 32); register_form = FALSE; opcode = �0010�; // = SUB
12116 imm32 = Bits32 (opcode, 7, 0);
12127 // n = UInt(Rn); imm32 = ARMExpandImm(imm12); register_form = FALSE;
12129 imm32 = ARMExpandImm (opcode);
12150 // operand2 = if register_form then Shift(R[m], shift_t, shift_n, APSR.C) else imm32;
12164 operand2 = imm32;