Rehash and clean up BPF JIT compiler macros to match AT&T notations.

1 files changed, 88 insertions, 88 deletions

diff --git a/sys/amd64/amd64/bpf_jit_machdep.c b/sys/amd64/amd64/bpf_jit_machdep.c
index b8c5190..638f9d8 100644
--- a/sys/amd64/amd64/bpf_jit_machdep.c
+++ b/sys/amd64/amd64/bpf_jit_machdep.c
@@ -132,11 +132,11 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 
 		/* create the procedure header */
 		PUSH(RBP);
-		MOVrq(RBP, RSP);
-		MOVoqd(RBP, -8, ESI);
-		MOVoqd(RBP, -12, EDX);
+		MOVrq(RSP, RBP);
+		MOVdoq(ESI, -8, RBP);
+		MOVdoq(EDX, -12, RBP);
 		PUSH(RBX);
-		MOVrq(RBX, RDI);
+		MOVrq(RDI, RBX);
 
 		for (i = 0; i < nins; i++) {
 			stream.bpf_pc++;
@@ -146,7 +146,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				return NULL;
 
 			case BPF_RET|BPF_K:
-				MOVid(EAX, ins->k);
+				MOVid(ins->k, EAX);
 				POP(RBX);
 				LEAVE_RET();
 				break;
@@ -157,119 +157,119 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_LD|BPF_W|BPF_ABS:
-				MOVid(ECX, ins->k);
-				MOVrd(ESI, ECX);
-				ADDib(ECX, sizeof(int));
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				MOVrd(ECX, ESI);
+				ADDib(sizeof(int), ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(5);
 				ZERO_EAX();
 				POP(RBX);
 				LEAVE_RET();
-				MOVobd(EAX, RBX, RSI);
+				MOVobd(RBX, RSI, EAX);
 				BSWAP(EAX);
 				break;
 
 			case BPF_LD|BPF_H|BPF_ABS:
 				ZERO_EAX();
-				MOVid(ECX, ins->k);
-				MOVrd(ESI, ECX);
-				ADDib(ECX, sizeof(short));
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				MOVrd(ECX, ESI);
+				ADDib(sizeof(short), ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(3);
 				POP(RBX);
 				LEAVE_RET();
-				MOVobw(AX, RBX, RSI);
+				MOVobw(RBX, RSI, AX);
 				SWAP_AX();
 				break;
 
 			case BPF_LD|BPF_B|BPF_ABS:
 				ZERO_EAX();
-				MOVid(ECX, ins->k);
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(3);
 				POP(RBX);
 				LEAVE_RET();
-				MOVobb(AL, RBX, RCX);
+				MOVobb(RBX, RCX, AL);
 				break;
 
 			case BPF_LD|BPF_W|BPF_LEN:
-				MOVodd(EAX, RBP, -8);
+				MOVoqd(-8, RBP, EAX);
 				break;
 
 			case BPF_LDX|BPF_W|BPF_LEN:
-				MOVodd(EDX, RBP, -8);
+				MOVoqd(-8, RBP, EDX);
 				break;
 
 			case BPF_LD|BPF_W|BPF_IND:
-				MOVid(ECX, ins->k);
-				ADDrd(ECX, EDX);
-				MOVrd(ESI, ECX);
-				ADDib(ECX, sizeof(int));
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				ADDrd(EDX, ECX);
+				MOVrd(ECX, ESI);
+				ADDib(sizeof(int), ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(5);
 				ZERO_EAX();
 				POP(RBX);
 				LEAVE_RET();
-				MOVobd(EAX, RBX, RSI);
+				MOVobd(RBX, RSI, EAX);
 				BSWAP(EAX);
 				break;
 
 			case BPF_LD|BPF_H|BPF_IND:
 				ZERO_EAX();
-				MOVid(ECX, ins->k);
-				ADDrd(ECX, EDX);
-				MOVrd(ESI, ECX);
-				ADDib(ECX, sizeof(short));
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				ADDrd(EDX, ECX);
+				MOVrd(ECX, ESI);
+				ADDib(sizeof(short), ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(3);
 				POP(RBX);
 				LEAVE_RET();
-				MOVobw(AX, RBX, RSI);
+				MOVobw(RBX, RSI, AX);
 				SWAP_AX();
 				break;
 
 			case BPF_LD|BPF_B|BPF_IND:
 				ZERO_EAX();
-				MOVid(ECX, ins->k);
-				ADDrd(ECX, EDX);
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				ADDrd(EDX, ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(3);
 				POP(RBX);
 				LEAVE_RET();
-				MOVobb(AL, RBX, RCX);
+				MOVobb(RBX, RCX, AL);
 				break;
 
 			case BPF_LDX|BPF_MSH|BPF_B:
-				MOVid(ECX, ins->k);
-				CMPodd(ECX, RBP, -12);
+				MOVid(ins->k, ECX);
+				CMPoqd(-12, RBP, ECX);
 				JLEb(5);
 				ZERO_EAX();
 				POP(RBX);
 				LEAVE_RET();
 				ZERO_EDX();
-				MOVobb(DL, RBX, RCX);
-				ANDib(DL, 0xf);
-				SHLib(EDX, 2);
+				MOVobb(RBX, RCX, DL);
+				ANDib(0xf, DL);
+				SHLib(2, EDX);
 				break;
 
 			case BPF_LD|BPF_IMM:
-				MOVid(EAX, ins->k);
+				MOVid(ins->k, EAX);
 				break;
 
 			case BPF_LDX|BPF_IMM:
-				MOVid(EDX, ins->k);
+				MOVid(ins->k, EDX);
 				break;
 
 			case BPF_LD|BPF_MEM:
-				MOViq(RCX, (uintptr_t)mem);
-				MOVid(ESI, ins->k * 4);
-				MOVobd(EAX, RCX, RSI);
+				MOViq((uintptr_t)mem, RCX);
+				MOVid(ins->k * 4, ESI);
+				MOVobd(RCX, RSI, EAX);
 				break;
 
 			case BPF_LDX|BPF_MEM:
-				MOViq(RCX, (uintptr_t)mem);
-				MOVid(ESI, ins->k * 4);
-				MOVobd(EDX, RCX, RSI);
+				MOViq((uintptr_t)mem, RCX);
+				MOVid(ins->k * 4, ESI);
+				MOVobd(RCX, RSI, EDX);
 				break;
 
 			case BPF_ST:
@@ -278,15 +278,15 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				 * be optimized if the previous instruction
 				 * was already of this type
 				 */
-				MOViq(RCX, (uintptr_t)mem);
-				MOVid(ESI, ins->k * 4);
-				MOVomd(RCX, RSI, EAX);
+				MOViq((uintptr_t)mem, RCX);
+				MOVid(ins->k * 4, ESI);
+				MOVomd(EAX, RCX, RSI);
 				break;
 
 			case BPF_STX:
-				MOViq(RCX, (uintptr_t)mem);
-				MOVid(ESI, ins->k * 4);
-				MOVomd(RCX, RSI, EDX);
+				MOViq((uintptr_t)mem, RCX);
+				MOVid(ins->k * 4, ESI);
+				MOVomd(EDX, RCX, RSI);
 				break;
 
 			case BPF_JMP|BPF_JA:
@@ -295,7 +295,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JGT|BPF_K:
-				CMPid(EAX, ins->k);
+				CMPid(ins->k, EAX);
 				/* 5 is the size of the following JMP */
 				JG(stream.refs[stream.bpf_pc + ins->jt] -
 				    stream.refs[stream.bpf_pc] + 5 );
@@ -304,7 +304,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JGE|BPF_K:
-				CMPid(EAX, ins->k);
+				CMPid(ins->k, EAX);
 				JGE(stream.refs[stream.bpf_pc + ins->jt] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jf] -
@@ -312,7 +312,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JEQ|BPF_K:
-				CMPid(EAX, ins->k);
+				CMPid(ins->k, EAX);
 				JE(stream.refs[stream.bpf_pc + ins->jt] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jf] -
@@ -320,8 +320,8 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JSET|BPF_K:
-				MOVrd(ECX, EAX);
-				ANDid(ECX, ins->k);
+				MOVrd(EAX, ECX);
+				ANDid(ins->k, ECX);
 				JE(stream.refs[stream.bpf_pc + ins->jf] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jt] -
@@ -329,7 +329,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JGT|BPF_X:
-				CMPrd(EAX, EDX);
+				CMPrd(EDX, EAX);
 				JA(stream.refs[stream.bpf_pc + ins->jt] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jf] -
@@ -337,7 +337,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JGE|BPF_X:
-				CMPrd(EAX, EDX);
+				CMPrd(EDX, EAX);
 				JAE(stream.refs[stream.bpf_pc + ins->jt] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jf] -
@@ -345,7 +345,7 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JEQ|BPF_X:
-				CMPrd(EAX, EDX);
+				CMPrd(EDX, EAX);
 				JE(stream.refs[stream.bpf_pc + ins->jt] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jf] -
@@ -353,8 +353,8 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_JMP|BPF_JSET|BPF_X:
-				MOVrd(ECX, EAX);
-				ANDrd(ECX, EDX);
+				MOVrd(EAX, ECX);
+				ANDrd(EDX, ECX);
 				JE(stream.refs[stream.bpf_pc + ins->jf] -
 				    stream.refs[stream.bpf_pc] + 5);
 				JMP(stream.refs[stream.bpf_pc + ins->jt] -
@@ -362,46 +362,46 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_ALU|BPF_ADD|BPF_X:
-				ADDrd(EAX, EDX);
+				ADDrd(EDX, EAX);
 				break;
 
 			case BPF_ALU|BPF_SUB|BPF_X:
-				SUBrd(EAX, EDX);
+				SUBrd(EDX, EAX);
 				break;
 
 			case BPF_ALU|BPF_MUL|BPF_X:
-				MOVrd(ECX, EDX);
-				MULrd(EDX);
 				MOVrd(EDX, ECX);
+				MULrd(EDX);
+				MOVrd(ECX, EDX);
 				break;
 
 			case BPF_ALU|BPF_DIV|BPF_X:
-				CMPid(EDX, 0);
+				CMPid(0, EDX);
 				JNEb(5);
 				ZERO_EAX();
 				POP(RBX);
 				LEAVE_RET();
-				MOVrd(ECX, EDX);
+				MOVrd(EDX, ECX);
 				ZERO_EDX();
 				DIVrd(ECX);
-				MOVrd(EDX, ECX);
+				MOVrd(ECX, EDX);
 				break;
 
 			case BPF_ALU|BPF_AND|BPF_X:
-				ANDrd(EAX, EDX);
+				ANDrd(EDX, EAX);
 				break;
 
 			case BPF_ALU|BPF_OR|BPF_X:
-				ORrd(EAX, EDX);
+				ORrd(EDX, EAX);
 				break;
 
 			case BPF_ALU|BPF_LSH|BPF_X:
-				MOVrd(ECX, EDX);
+				MOVrd(EDX, ECX);
 				SHL_CLrb(EAX);
 				break;
 
 			case BPF_ALU|BPF_RSH|BPF_X:
-				MOVrd(ECX, EDX);
+				MOVrd(EDX, ECX);
 				SHR_CLrb(EAX);
 				break;
 
@@ -414,34 +414,34 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_ALU|BPF_MUL|BPF_K:
-				MOVrd(ECX, EDX);
-				MOVid(EDX, ins->k);
-				MULrd(EDX);
 				MOVrd(EDX, ECX);
+				MOVid(ins->k, EDX);
+				MULrd(EDX);
+				MOVrd(ECX, EDX);
 				break;
 
 			case BPF_ALU|BPF_DIV|BPF_K:
-				MOVrd(ECX, EDX);
+				MOVrd(EDX, ECX);
 				ZERO_EDX();
-				MOVid(ESI, ins->k);
+				MOVid(ins->k, ESI);
 				DIVrd(ESI);
-				MOVrd(EDX, ECX);
+				MOVrd(ECX, EDX);
 				break;
 
 			case BPF_ALU|BPF_AND|BPF_K:
-				ANDid(EAX, ins->k);
+				ANDid(ins->k, EAX);
 				break;
 
 			case BPF_ALU|BPF_OR|BPF_K:
-				ORid(EAX, ins->k);
+				ORid(ins->k, EAX);
 				break;
 
 			case BPF_ALU|BPF_LSH|BPF_K:
-				SHLib(EAX, (ins->k) & 255);
+				SHLib((ins->k) & 0xff, EAX);
 				break;
 
 			case BPF_ALU|BPF_RSH|BPF_K:
-				SHRib(EAX, (ins->k) & 255);
+				SHRib((ins->k) & 0xff, EAX);
 				break;
 
 			case BPF_ALU|BPF_NEG:
@@ -449,11 +449,11 @@ bpf_jit_compile(struct bpf_insn *prog, u_int nins, int *mem)
 				break;
 
 			case BPF_MISC|BPF_TAX:
-				MOVrd(EDX, EAX);
+				MOVrd(EAX, EDX);
 				break;
 
 			case BPF_MISC|BPF_TXA:
-				MOVrd(EAX, EDX);
+				MOVrd(EDX, EAX);
 				break;
 			}
 			ins++;