R3
#define _ASM_MACRO_3R(OP, R1, R2, R3, ENC) \
".macro " #OP " " #R1 ", " #R2 ", " #R3 "\n\t" \
"parse_r __" #R3 ", \\" #R3 "\n\t" \
ret = emulate_ldh(regs, R3(regs->iir));
ret = emulate_ldw(regs, R3(regs->iir), 0);
ret = emulate_ldd(regs, R3(regs->iir), 0);
ret = emulate_ldd(regs, R3(regs->iir), 1);
ret = emulate_std(regs, R3(regs->iir), 1);
stepped = emulate_step(®s, ppc_inst(PPC_RAW_LXVD2X(39, R3, R4)));
stepped = emulate_step(®s, ppc_inst(PPC_RAW_STXVD2X(39, R3, R4)));
#define emit_sub(R1, R2, R3) \
*prog++ = (SUB | RS1(R1) | RS2(R2) | RD(R3))
#define emit_subi(R1, IMM, R3) \
*prog++ = (SUB | IMMED | RS1(R1) | S13(IMM) | RD(R3))
#define emit_add(R1, R2, R3) \
*prog++ = (ADD | RS1(R1) | RS2(R2) | RD(R3))
#define emit_addi(R1, IMM, R3) \
*prog++ = (ADD | IMMED | RS1(R1) | S13(IMM) | RD(R3))
#define emit_and(R1, R2, R3) \
*prog++ = (AND | RS1(R1) | RS2(R2) | RD(R3))
#define emit_andi(R1, IMM, R3) \
*prog++ = (AND | IMMED | RS1(R1) | S13(IMM) | RD(R3))
state->if_agc_cfg.R3 = (u16) (ulIfAgcR3);
state->rf_agc_cfg.R3 = (u16) (ulRfAgcR3);
u16 R3;
u32 R3 = state->if_agc_cfg.R3;
if (R2 == 0 && (R1 == 0 || R3 == 0))
Rpar = (R2 * R3) / (R3 + R2);
#define RL(s, v) R3("lu", s, v)
#define R(s, v) R3("lu", s, v)
R3("u", "RspQNullInts:", rspq.unhandled_irqs);
wr(scc,R3,0);
or(scc,R3,ENT_HM|RxENABLE); /* enable the receiver, hunt mode */
cl(scc,R3,ENT_HM|RxENABLE); /* disable the receiver */
or(scc,R3,ENT_HM); /* enter hunt mode for next flag */
or(scc, R3, ENT_HM);
or(scc, R3, ENT_HM);
or(scc,R3,ENT_HM); /* enter hunt mode for next flag */
for (k = 0; InReg(ctrl->chan_A,R3) && k < SCC_IRQTIMEOUT; k++)
wr(scc,R3,Rx8|RxCRC_ENAB); /* RX 8 bits/char, CRC, disabled */
cl(scc, R3, RxENABLE|ENT_HM); /* switch off receiver */
cl(scc, R3, RxENABLE);
s32 R1, R2, R3;
R3 = (s32) le32_to_cpu(il->card_alive_init.therm_r3[1]);
R3 = (s32) le32_to_cpu(il->card_alive_init.therm_r3[0]);
D_TEMP("Calib values R[1-3]: %d %d %d R4: %d\n", R1, R2, R3, vt);
if (R3 == R1) {
temperature /= (R3 - R1);
ASPEED_PINCTRL_PIN(R3),
SIG_EXPR_LIST_DECL_SINGLE(R3, DDCCLK, DDCCLK, SIG_DESC_SET(SCU84, 14));
SIG_EXPR_LIST_DECL_SINGLE(R3, DASHR3, DASHR3, SIG_DESC_SET(SCU94, 9));
PIN_DECL_2(R3, GPIOJ6, DDCCLK, DASHR3);
FUNC_GROUP_DECL(DDCCLK, R3);
up->curregs[R3] = RxENAB | Rx8;
write_zsreg(channel, R3, regs[R3] & ~RxENAB);
write_zsreg(channel, R3, regs[R3]);
r3 = read_zsreg(channel, R3);
up->curregs[R3] |= RxENAB;
up->curregs[R3] &= ~RxENAB;
write_zsreg(uap, R3, regs[R3] & ~RxENABLE);
write_zsreg(uap, R3, regs[R3]);
r3 = read_zsreg(uap_a, R3);
uap->curregs[R3] = Rx8;
write_zsreg(uap, R3, uap->curregs[R3] |= RxENABLE);
uap->curregs[R3] &= ~RxENABLE;
up->curregs[R3] = RxENAB | Rx8;
up->curregs[R3] = RxENAB | Rx8;
write_zsreg(channel, R3, regs[R3] & ~RxENAB);
write_zsreg(channel, R3, regs[R3]);
r3 = read_zsreg(channel, R3);
up->curregs[R3] |= RxENAB;
up->curregs[R3] &= ~RxENAB;
up->curregs[R3] &= ~RxN_MASK;
up->curregs[R3] |= Rx5;
up->curregs[R3] |= Rx6;
up->curregs[R3] |= Rx7;
up->curregs[R3] |= Rx8;
write_zsreg(zport, R3, regs[3] & ~RxENABLE);
write_zsreg(zport, R3, regs[3]);
zs_intreg = read_zsreg(zport_a, R3);
write_zsreg(zport, R3, zport->regs[3]);
write_zsreg(zport, R3, zport->regs[3]);
i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
BPF_ALU64_REG(BPF_AND, R2, R3),
BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
BPF_ALU64_REG(BPF_AND, R2, R3),
BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
BPF_ALU64_REG(BPF_AND, R2, R3),
BPF_ALU64_IMM(BPF_MOV, R3, R3), \
BPF_JMP_IMM(BPF_JNE, R3, R3, 7), \
BPF_ALU64_IMM(BPF_MOV, R3, 3), \
BPF_JMP_IMM(BPF_JNE, R3, 3, 7), \
BPF_ALU64_REG(BPF_MOV, R3, R1), \
BPF_ALU64_REG(BPF_SUB, R1, R3), \
BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
BPF_ALU64_REG(BPF_MOV, R3, BPF_REG_FP),
BPF_STX_MEM(BPF_DW, R3, R1, -8),
BPF_STX_MEM(BPF_DW, R3, R2, -16),
i += __bpf_ld_imm64(&insns[i], R3, res);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 2);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
insns[i++] = BPF_LDX_MEM(BPF_DW, R3, R10, -8);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R2, R3, 2);
insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
insns[i++] = BPF_JMP32_REG(BPF_JEQ, R1, R3, 2);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R0, R3, 2);
insns[i++] = BPF_LDX_MEM(BPF_W, R3, R10, -4);
insns[i++] = BPF_JMP32_REG(BPF_JEQ, R2, R3, 2);
insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3,
insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
insn[i++] = BPF_ALU32_IMM(BPF_MOV, R3, (u32)(imm >> 32));
insn[i++] = BPF_ALU64_IMM(BPF_LSH, R3, 32);
insn[i++] = BPF_ALU64_REG(BPF_OR, R2, R3);
BPF_ALU64_IMM(BPF_MOV, R3, 3),
BPF_ALU64_IMM(BPF_ADD, R3, 20),
BPF_ALU64_IMM(BPF_SUB, R3, 10),
BPF_ALU64_REG(BPF_ADD, R0, R3),
BPF_ALU64_REG(BPF_ADD, R1, R3),
BPF_ALU64_REG(BPF_ADD, R2, R3),
BPF_ALU64_REG(BPF_ADD, R3, R0),
BPF_ALU64_REG(BPF_ADD, R3, R1),
BPF_ALU64_REG(BPF_ADD, R3, R2),
BPF_ALU64_REG(BPF_ADD, R3, R3),
BPF_ALU64_REG(BPF_ADD, R3, R4),
BPF_ALU64_REG(BPF_ADD, R3, R5),
BPF_ALU64_REG(BPF_ADD, R3, R6),
BPF_ALU64_REG(BPF_ADD, R3, R7),
BPF_ALU64_REG(BPF_ADD, R3, R8),
BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
BPF_ALU64_REG(BPF_ADD, R4, R3),
BPF_ALU64_REG(BPF_ADD, R5, R3),
BPF_ALU64_REG(BPF_ADD, R6, R3),
BPF_ALU64_REG(BPF_ADD, R7, R3),
BPF_ALU64_REG(BPF_ADD, R8, R3),
BPF_ALU64_REG(BPF_ADD, R9, R3),
BPF_ALU32_IMM(BPF_MOV, R3, 3),
BPF_ALU64_IMM(BPF_ADD, R3, 10),
BPF_ALU32_REG(BPF_ADD, R0, R3),
BPF_ALU32_REG(BPF_ADD, R1, R3),
BPF_ALU32_REG(BPF_ADD, R2, R3),
BPF_ALU32_REG(BPF_ADD, R3, R0),
BPF_ALU32_REG(BPF_ADD, R3, R1),
BPF_ALU32_REG(BPF_ADD, R3, R2),
BPF_ALU32_REG(BPF_ADD, R3, R3),
BPF_ALU32_REG(BPF_ADD, R3, R4),
BPF_ALU32_REG(BPF_ADD, R3, R5),
BPF_ALU32_REG(BPF_ADD, R3, R6),
BPF_ALU32_REG(BPF_ADD, R3, R7),
BPF_ALU32_REG(BPF_ADD, R3, R8),
BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
BPF_ALU32_REG(BPF_ADD, R4, R3),
BPF_ALU32_REG(BPF_ADD, R5, R3),
BPF_ALU32_REG(BPF_ADD, R6, R3),
BPF_ALU32_REG(BPF_ADD, R7, R3),
BPF_ALU32_REG(BPF_ADD, R8, R3),
BPF_ALU32_REG(BPF_ADD, R9, R3),
BPF_ALU64_IMM(BPF_MOV, R3, 3),
BPF_ALU64_REG(BPF_SUB, R0, R3),
BPF_ALU64_REG(BPF_SUB, R1, R3),
BPF_ALU64_REG(BPF_SUB, R2, R3),
BPF_ALU64_REG(BPF_SUB, R3, R0),
BPF_ALU64_REG(BPF_SUB, R3, R1),
BPF_ALU64_REG(BPF_SUB, R3, R2),
BPF_ALU64_REG(BPF_SUB, R3, R4),
BPF_ALU64_REG(BPF_SUB, R3, R5),
BPF_ALU64_REG(BPF_SUB, R3, R6),
BPF_ALU64_REG(BPF_SUB, R3, R7),
BPF_ALU64_REG(BPF_SUB, R3, R8),
BPF_ALU64_REG(BPF_SUB, R3, R9),
BPF_ALU64_IMM(BPF_SUB, R3, 10),
BPF_ALU64_REG(BPF_SUB, R4, R3),
BPF_ALU64_REG(BPF_SUB, R5, R3),
BPF_ALU64_REG(BPF_SUB, R6, R3),
BPF_ALU64_REG(BPF_SUB, R7, R3),
BPF_ALU64_REG(BPF_SUB, R8, R3),
BPF_ALU64_REG(BPF_SUB, R9, R3),
BPF_ALU64_REG(BPF_SUB, R0, R3),
BPF_ALU64_REG(BPF_XOR, R3, R3),
BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
BPF_ALU64_REG(BPF_SUB, R3, R3),
BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
BPF_ALU64_IMM(BPF_MOV, R3, 1),
BPF_ALU64_IMM(BPF_MOV, R3, 3),
BPF_ALU64_REG(BPF_MUL, R0, R3),
BPF_ALU64_REG(BPF_MUL, R1, R3),
BPF_ALU64_REG(BPF_MUL, R2, R3),
BPF_MOV64_REG(R3, R2),
BPF_MOV64_REG(R4, R3),
BPF_ALU64_IMM(BPF_MOV, R3, 0),
BPF_ALU64_REG(BPF_ADD, R0, R3),
BPF_MOV64_REG(R3, R2),
BPF_MOV64_REG(R4, R3),
BPF_ALU32_IMM(BPF_MOV, R3, 0),
BPF_ALU64_REG(BPF_ADD, R0, R3),
BPF_MOV64_REG(R3, R2),
BPF_MOV64_REG(R4, R3),
BPF_LD_IMM64(R3, 0x0LL),
BPF_ALU64_REG(BPF_ADD, R0, R3),
BPF_MOV64_IMM(R3, 47),
BPF_ALU64_REG(BPF_ARSH, R0, R3),
BPF_MOV64_REG(R3, R2),
BPF_ALU64_IMM(BPF_LSH, R3, 32),
BPF_ALU64_IMM(BPF_RSH, R3, 32),
BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
BPF_MOVSX32_REG(R1, R3, 8),
BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
BPF_MOVSX32_REG(R1, R3, 16),
BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
BPF_MOVSX64_REG(R1, R3, 8),
BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
BPF_MOVSX64_REG(R1, R3, 16),
BPF_LD_IMM64(R3, 0xdeadbeefdeadbeefLL),
BPF_MOVSX64_REG(R1, R3, 32),
BPF_LD_IMM64(R3, 0x00000000ffffffff),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffff),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x7fffffff),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x80000000),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x80008000),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x1),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffff),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x7fffffff),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffff80000000LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffff80008000LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x00000000ffffffff),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0000000000000001LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x1UL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0000000000000001LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
i += __bpf_ld_imm64(&insn[i], R3, reg);
insn[i++] = BPF_ALU64_REG(BPF_MOV, R1, R3);
BPF_LD_IMM64(R3, 0x0000000000000000LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, 0x0000000000000088ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000000000088ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000000000088ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
BPF_LD_IMM64(R3, (update) | BPF_ATOMIC_POISON(width)), \
BPF_ATOMIC_OP(width, op, R10, R3, -40), \
BPF_ALU32_REG(BPF_MOV, R0, R3), \
BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
BPF_ALU32_REG(BPF_MOV, R0, R3),
i += __bpf_ld_imm64(&insns[i], R3, res);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
i += __bpf_ld_imm64(&insns[i], R3, (u32)res);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);
i += __bpf_ld_imm64(&insns[i], R3, res);
insns[i++] = BPF_JMP_REG(BPF_JEQ, R1, R3, 1);