Skip to main content

juicebox_asm/
insn.rs

1// SPDX-License-Identifier: MIT
2//
3// Copyright (c) 2023, Johannes Stoelp <dev@memzero.de>
4
5//! Trait definitions of various instructions.
6
7mod add;
8mod and;
9mod call;
10mod cmovnz;
11mod cmovz;
12mod cmp;
13mod dec;
14mod inc;
15mod int3;
16mod jae;
17mod jb;
18mod jge;
19mod jl;
20mod jmp;
21mod jnz;
22mod jz;
23mod lea;
24mod mov;
25mod movsx;
26mod movzx;
27mod nop;
28mod or;
29mod pop;
30mod push;
31mod ret;
32mod sar;
33mod setb;
34mod setl;
35mod shl;
36mod shr;
37mod sub;
38mod test;
39mod xor;
40
41/// Trait for [`add`](https://www.felixcloutier.com/x86/add) instruction kinds.
42pub trait Add<T, U> {
43    /// Emit an add instruction.
44    fn add(&mut self, op1: T, op2: U);
45}
46
47/// Trait for [`and`](https://www.felixcloutier.com/x86/and) instruction kinds.
48pub trait And<T, U> {
49    /// Emit an and instruction.
50    fn and(&mut self, op1: T, op2: U);
51}
52
53/// Trait for [`call`](https://www.felixcloutier.com/x86/call) instruction kinds.
54pub trait Call<T> {
55    /// Emit a call instruction.
56    fn call(&mut self, op1: T);
57}
58
59/// Trait for [`cmovnz`](https://www.felixcloutier.com/x86/cmovcc) instruction kinds.
60pub trait Cmovnz<T, U> {
61    /// Emit a (conditional) move if not zero instruction.
62    ///
63    /// Move is only commited if (ZF=0).
64    fn cmovnz(&mut self, op1: T, op2: U);
65}
66
67/// Trait for [`cmovz`](https://www.felixcloutier.com/x86/cmovcc) instruction kinds.
68pub trait Cmovz<T, U> {
69    /// Emit a (conditional) move if zero instruction.
70    ///
71    /// Move is only commited if (ZF=1).
72    fn cmovz(&mut self, op1: T, op2: U);
73}
74
75/// Trait for [`cmp`](https://www.felixcloutier.com/x86/cmp) instruction kinds.
76pub trait Cmp<T, U> {
77    /// Emit a compare instruction.
78    ///
79    /// Computes `op2 - op1` and sets the status flags in the same way as the `sub` instruction,
80    /// the result is discarded.
81    fn cmp(&mut self, op1: T, op2: U);
82}
83
84/// Trait for [`dec`](https://www.felixcloutier.com/x86/dec) instruction kinds.
85pub trait Dec<T> {
86    /// Emit a decrement instruction.
87    fn dec(&mut self, op1: T);
88}
89
90/// Trait for [`inc`](https://www.felixcloutier.com/x86/inc) instruction kinds.
91pub trait Inc<T> {
92    /// Emit a increment instruction.
93    fn inc(&mut self, op1: T);
94}
95
96/// Trait for [`jae`](https://www.felixcloutier.com/x86/jcc) instruction kinds.
97pub trait Jae<T> {
98    /// Emit a conditional jump if above or equal (`CF=0`).
99    /// This handles the flags from an unsigned arithmetic operation.
100    fn jae(&mut self, op1: T);
101}
102
103/// Trait for [`jb`](https://www.felixcloutier.com/x86/jcc) instruction kinds.
104pub trait Jb<T> {
105    /// Emit a conditional jump if below (`CF=1`).
106    /// This handles the flags from an unsigned arithmetic operation.
107    fn jb(&mut self, op1: T);
108}
109
110/// Trait for [`jge`](https://www.felixcloutier.com/x86/jcc) instruction kinds.
111pub trait Jge<T> {
112    /// Emit a conditional jump if greater or equal (`SF=OF`).
113    /// This handles the flags from a signed arithmetic operation.
114    fn jge(&mut self, op1: T);
115}
116
117/// Trait for [`jl`](https://www.felixcloutier.com/x86/jcc) instruction kinds.
118pub trait Jl<T> {
119    /// Emit a conditional jump if less (`SF!=OF`).
120    /// This handles the flags from a signed arithmetic operation.
121    fn jl(&mut self, op1: T);
122}
123
124/// Trait for [`jmp`](https://www.felixcloutier.com/x86/jmp) instruction kinds.
125pub trait Jmp<T> {
126    /// Emit an unconditional jump instruction.
127    fn jmp(&mut self, op1: T);
128}
129
130/// Trait for [`jnz`](https://www.felixcloutier.com/x86/jcc) instruction kinds.
131pub trait Jnz<T> {
132    /// Emit a conditional jump if not zero instruction (`ZF = 0`).
133    fn jnz(&mut self, op1: T);
134}
135
136/// Trait for [`jz`](https://www.felixcloutier.com/x86/jcc) instruction kinds.
137pub trait Jz<T> {
138    /// Emit a conditional jump if zero instruction (`ZF = 1`).
139    fn jz(&mut self, op1: T);
140}
141
142/// Trait for [`lea`](https://www.felixcloutier.com/x86/lea) instruction kinds.
143pub trait Lea<T, U> {
144    /// Emit a load effective address instruction.
145    fn lea(&mut self, op1: T, op2: U);
146}
147
148/// Trait for [`mov`](https://www.felixcloutier.com/x86/mov) instruction kinds.
149pub trait Mov<T, U> {
150    /// Emit an move instruction.
151    fn mov(&mut self, op1: T, op2: U);
152}
153
154/// Trait for [`movsx`](https://www.felixcloutier.com/x86/movsx:movsxd) instruction kinds.
155pub trait Movsx<T, U> {
156    /// Emit a sign-extend move instruction.
157    fn movsx(&mut self, op1: T, op2: U);
158}
159
160/// Trait for [`movzx`](https://www.felixcloutier.com/x86/movzx) instruction kinds.
161pub trait Movzx<T, U> {
162    /// Emit a zero-extend move instruction.
163    fn movzx(&mut self, op1: T, op2: U);
164}
165
166/// Trait for [`or`](https://www.felixcloutier.com/x86/or) instruction kinds.
167pub trait Or<T, U> {
168    /// Emit an or instruction.
169    fn or(&mut self, op1: T, op2: U);
170}
171
172/// Trait for [`pop`](https://www.felixcloutier.com/x86/pop) instruction kinds.
173pub trait Pop<T> {
174    /// Emit a pop instruction.
175    fn pop(&mut self, op1: T);
176}
177
178/// Trait for [`push`](https://www.felixcloutier.com/x86/push) instruction kinds.
179pub trait Push<T> {
180    /// Emit a push instruction.
181    fn push(&mut self, op1: T);
182}
183
184/// Trait for [`sar`](https://www.felixcloutier.com/x86/sal:sar:shl:shr) instruction kinds.
185pub trait Sar<T, U> {
186    /// Emit an arithmethic shift-right instruction.
187    fn sar(&mut self, op1: T, op2: U);
188}
189
190/// Trait for [`setb`](https://www.felixcloutier.com/x86/setcc) instruction kinds.
191pub trait Setb<T> {
192    /// Emit a set if below instruction.
193    /// This handles the flags from an unsigned arithmetic operation.
194    fn setb(&mut self, op1: T);
195}
196
197/// Trait for [`setl`](https://www.felixcloutier.com/x86/setcc) instruction kinds.
198pub trait Setl<T> {
199    /// Emit a set if less instruction.
200    /// This handles the flags from an signed arithmetic operation.
201    fn setl(&mut self, op1: T);
202}
203
204/// Trait for [`shl`](https://www.felixcloutier.com/x86/sal:sar:shl:shr) instruction kinds.
205pub trait Shl<T, U> {
206    /// Emit a logical shift-left instruction.
207    fn shl(&mut self, op1: T, op2: U);
208}
209
210/// Trait for [`shr`](https://www.felixcloutier.com/x86/sal:sar:shl:shr) instruction kinds.
211pub trait Shr<T, U> {
212    /// Emit a logical shift-right instruction.
213    fn shr(&mut self, op1: T, op2: U);
214}
215
216/// Trait for [`sub`](https://www.felixcloutier.com/x86/sub) instruction kinds.
217pub trait Sub<T, U> {
218    /// Emit an sub instruction.
219    fn sub(&mut self, op1: T, op2: U);
220}
221
222/// Trait for [`test`](https://www.felixcloutier.com/x86/test) instruction kinds.
223pub trait Test<T, U> {
224    /// Emit a logical compare instruction.
225    ///
226    /// Computes the bit-wise logical AND of first operand and the second operand and sets the
227    /// `SF`, `ZF`, and `PF` status flags, the result is discarded.
228    fn test(&mut self, op1: T, op2: U);
229}
230
231/// Trait for [`xor`](https://www.felixcloutier.com/x86/xor) instruction kinds.
232pub trait Xor<T, U> {
233    /// Emit a xor instruction.
234    fn xor(&mut self, op1: T, op2: U);
235}