Lines Matching defs:imm32
1149 (result, carry, overflow) = AddWithCarry(SP, imm32, '0');
1169 uint32_t imm32;
1173 imm32 = Bits32(opcode, 7, 0) << 2; // imm32 = ZeroExtend(imm8:'00', 32)
1177 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
1182 addr_t sp_offset = imm32;
1363 result = imm32;
1378 uint32_t imm32; // the immediate value to be written to Rd
1388 imm32 = Bits32(opcode, 7, 0); // imm32 = ZeroExtend(imm8, 32)
1396 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry);
1403 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:i:imm3:imm8,
1411 imm32 = (imm4 << 12) | (i << 11) | (imm3 << 8) | imm8;
1419 // d = UInt(Rd); setflags = (S == '1'); (imm32, carry) =
1423 imm32 = ARMExpandImm_C(opcode, APSR_C, carry);
1433 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm4:imm12, 32);
1438 imm32 = (imm4 << 12) | imm12;
1448 uint32_t result = imm32;
1605 result = NOT(imm32);
1620 uint32_t imm32; // the output after ThumbExpandImm_C or ARMExpandImm_C
1627 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry);
1632 imm32 = ARMExpandImm_C(opcode, APSR_C, carry);
1642 uint32_t result = ~imm32;
1747 address = if add then (base + imm32) else (base - imm32);
1775 uint32_t imm32; // immediate offset from the PC
1776 bool add; // +imm32 or -imm32?
1783 imm32 = Bits32(opcode, 7, 0) << 2; // imm32 = ZeroExtend(imm8:'00', 32);
1788 imm32 = Bits32(opcode, 11, 0) << 2; // imm32 = ZeroExtend(imm12, 32);
1799 address = base + imm32;
1801 address = base - imm32;
1834 (result, carry, overflow) = AddWithCarry(SP, imm32, '0');
1853 uint32_t imm32; // the immediate operand
1858 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(imm8:'00', 32);
1860 imm32 = (Bits32(opcode, 7, 0) << 2);
1865 // d = 13; setflags = FALSE; imm32 = ZeroExtend(imm7:'00', 32);
1867 imm32 = ThumbImm7Scaled(opcode); // imm32 = ZeroExtend(imm7:'00', 32)
1872 // d = UInt(Rd); setflags = (S == "1"); imm32 =
1875 imm32 = ThumbExpandImm(opcode);
1889 // d = UInt(Rd); setflags = FALSE; imm32 = ZeroExtend(i:imm3:imm8, 32);
1895 imm32 = (i << 11) | (imm3 << 8) | imm8;
1905 // (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
1906 AddWithCarryResult res = AddWithCarry(sp, imm32, 0);
2010 targetAddress = Align(PC,4) + imm32;
2012 targetAddress = PC + imm32;
2028 int32_t imm32; // PC-relative offset
2041 imm32 = llvm::SignExtend32<25>(imm25);
2042 target = pc + imm32;
2044 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2060 imm32 = llvm::SignExtend32<25>(imm25);
2061 target = Align(pc, 4) + imm32;
2063 context.SetISAAndImmediateSigned(eModeARM, 4 + imm32);
2070 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2);
2071 target = Align(pc, 4) + imm32;
2073 context.SetISAAndImmediateSigned(eModeARM, 8 + imm32);
2077 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2 |
2079 target = pc + imm32;
2081 context.SetISAAndImmediateSigned(eModeThumb, 8 + imm32);
2275 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
2293 uint32_t imm32;
2296 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2301 addr_t ip_offset = imm32;
2325 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
2343 uint32_t imm32;
2346 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2351 addr_t sp_offset = imm32;
2378 (result, carry, overflow) = AddWithCarry(SP, NOT(imm32), '1');
2399 uint32_t imm32;
2404 imm32 = ThumbImm7Scaled(opcode); // imm32 = ZeroExtend(imm7:'00', 32)
2409 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
2418 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
2425 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
2435 AddWithCarryResult res = AddWithCarry(sp, ~imm32, 1);
2439 uint64_t imm64 = imm32; // Need to expand it to 64 bits before attempting
2464 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
2558 address = SP - imm32;
2559 SP = SP - imm32;
2581 uint32_t imm32; // stack offset
2588 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2599 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2610 addr_t sp_offset = imm32;
2652 SP = SP + imm32;
2673 uint32_t imm32; // stack offset
2680 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2691 imm32 = Bits32(opcode, 7, 0) * addr_byte_size;
2702 addr_t sp_offset = imm32;
2751 uint32_t imm32; // the immediate constant
2756 imm32 = Bits32(opcode, 7, 0);
2761 imm32 = Bits32(opcode, 23, 0);
2770 context.SetISAAndImmediate(mode, imm32);
2805 BranchWritePC(PC + imm32);
2818 int32_t imm32; // PC-relative offset
2822 imm32 = llvm::SignExtend32<9>(Bits32(opcode, 7, 0) << 1);
2823 target = pc + imm32;
2824 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2827 imm32 = llvm::SignExtend32<12>(Bits32(opcode, 10, 0) << 1);
2828 target = pc + imm32;
2829 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2845 imm32 = llvm::SignExtend32<21>(imm21);
2846 target = pc + imm32;
2847 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2860 imm32 = llvm::SignExtend32<25>(imm25);
2861 target = pc + imm32;
2862 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
2866 imm32 = llvm::SignExtend32<26>(Bits32(opcode, 23, 0) << 2);
2867 target = pc + imm32;
2868 context.SetISAAndImmediateSigned(eModeARM, 8 + imm32);
2888 BranchWritePC(PC + imm32);
2905 uint32_t imm32; // PC-relative offset to branch forward
2909 imm32 = Bit32(opcode, 9) << 6 | Bits32(opcode, 7, 3) << 1;
2911 target = pc + imm32;
2912 context.SetISAAndImmediateSigned(eModeThumb, 4 + imm32);
3015 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3030 uint32_t imm32;
3036 // d = UInt(Rd); n = UInt(Rn); setflags = !InITBlock(); imm32 =
3041 imm32 = Bits32(opcode, 8, 6);
3046 // d = UInt(Rdn); n = UInt(Rdn); setflags = !InITBlock(); imm32 =
3051 imm32 = Bits32(opcode, 7, 0);
3057 // d = UInt(Rd); n = UInt(Rn); setflags = (S == '1'); imm32 =
3062 imm32 = ThumbExpandImm_C(opcode, APSR_C, carry_out);
3076 // d = UInt(Rd); n = UInt(Rn); setflags = FALSE; imm32 =
3084 imm32 = (i << 11) | (imm3 << 8) | imm8;
3106 //(result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3107 AddWithCarryResult res = AddWithCarry(Rn, imm32, 0);
3113 context.SetRegisterPlusOffset(*reg_n, imm32);
3137 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3154 imm32; // the immediate value to be added to the value obtained from Rn
3161 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
3172 AddWithCarryResult res = AddWithCarry(val1, imm32, 0);
3184 context.SetRegisterPlusOffset(*dwarf_reg, imm32);
3291 (result, carry, overflow) = AddWithCarry(R[n], imm32, '0');
3301 uint32_t imm32; // the immediate value to be compared with
3305 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
3311 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
3321 AddWithCarryResult res = AddWithCarry(reg_val, imm32, 0);
3404 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
3414 uint32_t imm32; // the immediate value to be compared with
3418 imm32 = Bits32(opcode, 7, 0);
3422 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
3428 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
3438 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
4413 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
4430 uint32_t imm32; // the immediate offset used to form the address
4439 imm32 = Bits32(opcode, 10, 6) << 2; // imm32 = ZeroExtend(imm5:'00', 32);
4448 // t = UInt(Rt); n = 13; imm32 = ZeroExtend(imm8:'00', 32);
4451 imm32 = Bits32(opcode, 7, 0) << 2;
4462 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
4465 imm32 = Bits32(opcode, 11, 0);
4487 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
4490 imm32 = Bits32(opcode, 7, 0);
4512 offset_addr = base + imm32;
4514 offset_addr = base - imm32;
5119 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5135 uint32_t imm32;
5142 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5:'00', 32);
5145 imm32 = Bits32(opcode, 10, 6) << 2;
5154 // t = UInt(Rt); n = 13; imm32 = ZeroExtend(imm8:'00', 32);
5157 imm32 = Bits32(opcode, 7, 0) << 2;
5170 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
5173 imm32 = Bits32(opcode, 11, 0);
5194 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
5197 imm32 = Bits32(opcode, 7, 0);
5216 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5222 offset_addr = base_address + imm32;
5224 offset_addr = base_address - imm32;
5475 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5486 uint32_t imm32;
5493 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5, 32);
5496 imm32 = Bits32(opcode, 10, 6);
5509 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
5512 imm32 = Bits32(opcode, 11, 0);
5530 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
5533 imm32 = Bits32(opcode, 7, 0);
5556 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
5558 offset_addr = base_address + imm32;
5560 offset_addr = base_address - imm32;
5786 (result, carry, overflow) = AddWithCarry(R[n], imm32, APSR.C);
5803 imm32; // the immediate value to be added to the value obtained from Rn
5810 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
5818 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
5832 AddWithCarryResult res = AddWithCarry(val1, imm32, APSR_C);
5940 result = if add then (Align(PC,4) + imm32) else (Align(PC,4) - imm32);
5951 uint32_t imm32; // the immediate value to be added/subtracted to/from the PC
5956 imm32 = ThumbImm8Scaled(opcode); // imm32 = ZeroExtend(imm8:'00', 32)
5962 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
5970 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
5982 uint32_t result = (add ? Align(pc, 4) + imm32 : Align(pc, 4) - imm32);
6003 result = R[n] AND imm32;
6020 imm32; // the immediate value to be ANDed to the value obtained from Rn
6028 imm32 = ThumbExpandImm_C(
6030 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
6041 imm32 =
6043 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
6057 uint32_t result = val1 & imm32;
6168 result = R[n] AND NOT(imm32);
6184 uint32_t imm32; // the immediate value to be bitwise inverted and ANDed to
6193 imm32 = ThumbExpandImm_C(
6195 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
6203 imm32 =
6205 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
6221 uint32_t result = val1 & ~imm32;
6331 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6350 uint32_t imm32;
6361 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6364 imm32 = Bits32(opcode, 11, 0);
6388 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6390 offset_addr = base_address + imm32;
6392 offset_addr = base_address - imm32;
6673 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6684 uint32_t imm32;
6692 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5, 32);
6695 imm32 = Bits32(opcode, 10, 6);
6705 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
6708 imm32 = Bits32(opcode, 11, 0);
6735 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
6738 imm32 = Bits32(opcode, 7, 0);
6771 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
6773 offset_addr = Rn + imm32;
6775 offset_addr = Rn - imm32;
6821 address = if add then (base + imm32) else (base - imm32);
6829 uint32_t imm32;
6833 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6835 imm32 = Bits32(opcode, 11, 0);
6849 // t == UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
6851 imm32 = Bits32(opcode, 11, 0);
6871 // address = if add then (base + imm32) else (base - imm32);
6873 address = base + imm32;
6875 address = base - imm32;
7063 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7078 uint32_t imm32;
7086 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm5:'0', 32);
7089 imm32 = Bits32(opcode, 10, 6) << 1;
7101 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7104 imm32 = Bits32(opcode, 11, 0);
7125 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7128 imm32 = Bits32(opcode, 7, 0);
7144 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7154 offset_addr = Rn + imm32;
7156 offset_addr = Rn - imm32;
7211 address = if add then (base + imm32) else (base - imm32);
7223 uint32_t imm32;
7230 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
7232 imm32 = Bits32(opcode, 11, 0);
7245 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
7247 imm32 = (imm4H << 4) | imm4L;
7268 // address = if add then (base + imm32) else (base - imm32);
7270 address = base + imm32;
7272 address = base - imm32;
7490 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7501 uint32_t imm32;
7511 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7514 imm32 = Bits32(opcode, 11, 0);
7535 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7538 imm32 = Bits32(opcode, 7, 0);
7557 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
7563 imm32 = (imm4H << 4) | imm4L;
7589 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7591 offset_addr = Rn + imm32;
7593 offset_addr = Rn - imm32;
7640 address = if add then (base + imm32) else (base - imm32);
7648 uint32_t imm32;
7655 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
7657 imm32 = Bits32(opcode, 11, 0);
7667 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
7671 imm32 = (imm4H << 4) | imm4L;
7691 // address = if add then (base + imm32) else (base - imm32);
7694 address = base + imm32;
7696 address = base - imm32;
7887 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7902 uint32_t imm32;
7912 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
7915 imm32 = Bits32(opcode, 11, 0);
7937 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm8, 32);
7940 imm32 = Bits32(opcode, 7, 0);
7956 // t == UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L, 32);
7961 imm32 = (imm4H << 4) | imm4L;
7980 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
7988 offset_addr = Rn + imm32;
7990 offset_addr = Rn - imm32;
8047 address = if add then (base + imm32) else (base - imm32);
8059 uint32_t imm32;
8066 // t = UInt(Rt); imm32 = ZeroExtend(imm12, 32); add = (U == '1');
8068 imm32 = Bits32(opcode, 11, 0);
8078 // t == UInt(Rt); imm32 = ZeroExtend(imm4H:imm4L, 32); add = (U == '1');
8082 imm32 = (imm4H << 4) | imm4L;
8103 // address = if add then (base + imm32) else (base - imm32);
8105 address = base + imm32;
8107 address = base - imm32;
8115 context.SetRegisterPlusOffset(*base_reg, imm32);
8807 result = R[n] EOR imm32;
8824 imm32; // the immediate value to be ORed to the value obtained from Rn
8832 imm32 = ThumbExpandImm_C(
8834 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
8845 imm32 =
8847 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
8863 uint32_t result = val1 ^ imm32;
8976 result = R[n] OR imm32;
8993 imm32; // the immediate value to be ORed to the value obtained from Rn
9001 imm32 = ThumbExpandImm_C(
9003 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9014 imm32 =
9016 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9030 uint32_t result = val1 | imm32;
9141 (result, carry, overflow) = AddWithCarry(NOT(R[n]), imm32, '1');
9159 imm32; // the immediate value to be added to the value obtained from Rn
9165 imm32 = 0;
9171 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9179 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9194 AddWithCarryResult res = AddWithCarry(~reg_val, imm32, 1);
9292 (result, carry, overflow) = AddWithCarry(NOT(R[n]), imm32, APSR.C);
9310 imm32; // the immediate value to be added to the value obtained from Rn
9316 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9331 AddWithCarryResult res = AddWithCarry(~reg_val, imm32, APSR_C);
9421 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), APSR.C);
9439 imm32; // the immediate value to be added to the value obtained from Rn
9445 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9453 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9468 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, APSR_C);
9573 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
9587 uint32_t imm32; // the immediate value to be subtracted from the value
9594 imm32 = Bits32(opcode, 8, 6); // imm32 = ZeroExtend(imm3, 32)
9599 imm32 = Bits32(opcode, 7, 0); // imm32 = ZeroExtend(imm8, 32)
9605 imm32 = ThumbExpandImm(opcode); // imm32 = ThumbExpandImm(i:imm3:imm8)
9623 imm32 = ThumbImm12(opcode); // imm32 = ZeroExtend(i:imm3:imm8, 32)
9644 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
9663 (result, carry, overflow) = AddWithCarry(R[n], NOT(imm32), '1');
9681 uint32_t imm32; // the immediate value to be subtracted from the value
9688 imm32 = ARMExpandImm(opcode); // imm32 = ARMExpandImm(imm12)
9711 AddWithCarryResult res = AddWithCarry(reg_val, ~imm32, 1);
9721 int64_t imm32_signed = imm32;
9740 result = R[n] EOR imm32;
9752 imm32; // the immediate value to be ANDed to the value obtained from Rn
9757 imm32 = ThumbExpandImm_C(
9759 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9765 imm32 =
9767 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9778 uint32_t result = val1 ^ imm32;
9865 result = R[n] AND imm32;
9877 imm32; // the immediate value to be ANDed to the value obtained from Rn
9882 imm32 = ThumbExpandImm_C(
9884 carry); // (imm32, carry) = ThumbExpandImm(i:imm3:imm8, APSR.C)
9890 imm32 =
9892 carry); // (imm32, carry) = ARMExpandImm(imm12, APSR.C)
9903 uint32_t result = val1 & imm32;
10321 address = R[n] + imm32;
10335 uint32_t imm32;
10340 // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 =
10346 imm32 = Bits32(opcode, 7, 0) << 2;
10359 // d = UInt(Rd); t = UInt(Rt); n = UInt(Rn); imm32 = Zeros(32); // Zero
10364 imm32 = 0;
10380 // address = R[n] + imm32;
10385 addr_t address = Rn + imm32;
10393 context.SetRegisterToRegisterPlusOffset(*data_reg, *base_reg, imm32);
10432 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10443 uint32_t imm32;
10451 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
10454 imm32 = Bits32(opcode, 11, 0);
10475 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10482 offset_addr = Rn + imm32;
10484 offset_addr = Rn - imm32;
10525 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10536 uint32_t imm32;
10548 // t = UInt(Rt); n = UInt(Rn); imm32 = ZeroExtend(imm12, 32);
10551 imm32 = Bits32(opcode, 11, 0);
10568 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10575 offset_addr = Rn + imm32;
10577 offset_addr = Rn - imm32;
10634 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10647 uint32_t imm32;
10656 // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
10661 imm32 = Bits32(opcode, 7, 0) << 2;
10681 // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L,
10688 imm32 = (Bits32(opcode, 11, 8) << 4) | Bits32(opcode, 3, 0);
10713 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10720 offset_addr = Rn + imm32;
10722 offset_addr = Rn - imm32;
10905 offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10918 uint32_t imm32;
10926 // t = UInt(Rt); t2 = UInt(Rt2); n = UInt(Rn); imm32 =
10931 imm32 = Bits32(opcode, 7, 0) << 2;
10950 // t = UInt(Rt); t2 = t+1; n = UInt(Rn); imm32 = ZeroExtend(imm4H:imm4L,
10958 imm32 = (Bits32(opcode, 11, 8) << 4) | Bits32(opcode, 3, 0);
10990 // offset_addr = if add then (R[n] + imm32) else (R[n] - imm32);
10993 offset_addr = Rn + imm32;
10995 offset_addr = Rn - imm32;
11195 address = if add then R[n] else R[n]-imm32;
11196 if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11215 uint32_t imm32;
11235 // d = UInt(D:Vd); n = UInt(Rn); imm32 = ZeroExtend(imm8:'00', 32);
11238 imm32 = Bits32(opcode, 7, 0) << 2;
11273 // imm32 = ZeroExtend(imm8:'00', 32); regs = UInt(imm8);
11274 imm32 = Bits32(opcode, 7, 0) << 2;
11295 // address = if add then R[n] else R[n]-imm32;
11300 address = Rn - imm32;
11302 // if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11308 value = Rn + imm32;
11310 value = Rn - imm32;
11388 address = if add then R[n] else R[n]-imm32;
11389 if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11409 uint32_t imm32;
11429 // d = UInt(D:Vd); n = UInt(Rn); imm32 = ZeroExtend(imm8:'00', 32);
11432 imm32 = Bits32(opcode, 7, 0) << 2;
11467 // imm32 = ZeroExtend(imm8:'00', 32); regs = UInt(imm8);
11468 imm32 = Bits32(opcode, 7, 0) << 2;
11493 // address = if add then R[n] else R[n]-imm32;
11498 address = Rn - imm32;
11501 // if wback then R[n] = if add then R[n]+imm32 else R[n]-imm32;
11505 value = Rn + imm32;
11507 value = Rn - imm32;
11594 address = if add then (base + imm32) else (base - imm32);
11609 uint32_t imm32;
11616 // single_reg = FALSE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00',
11620 imm32 = Bits32(opcode, 7, 0) << 2;
11630 // single_reg = TRUE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00', 32);
11633 imm32 = Bits32(opcode, 7, 0) << 2;
11658 // address = if add then (base + imm32) else (base - imm32);
11661 address = base + imm32;
11663 address = base - imm32;
11720 address = if add then (R[n] + imm32) else (R[n] - imm32);
11735 uint32_t imm32;
11742 // single_reg = FALSE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00',
11746 imm32 = Bits32(opcode, 7, 0) << 2;
11760 // single_reg = TRUE; add = (U == '1'); imm32 = ZeroExtend(imm8:'00', 32);
11763 imm32 = Bits32(opcode, 7, 0) << 2;
11783 // address = if add then (R[n] + imm32) else (R[n] - imm32);
11786 address = Rn + imm32;
11788 address = Rn - imm32;
12633 operand2 = if register_form then Shift(R[m], shift_t, shift_n, APSR.C) else imm32;
12656 uint32_t imm32;
12665 // imm32 = ZeroExtend(imm8, 32); register_form = FALSE; opcode = '0010';
12668 imm32 = Bits32(opcode, 7, 0);
12679 // n = UInt(Rn); imm32 = ARMExpandImm(imm12); register_form = FALSE;
12681 imm32 = ARMExpandImm(opcode);
12703 // else imm32;
12714 operand2 = imm32;