1 //===- X86InstrArithmetic.td - Integer Arithmetic Instrs ---*- tablegen -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file describes the integer arithmetic instructions in the X86
13 //===----------------------------------------------------------------------===//
15 //===----------------------------------------------------------------------===//
16 // LEA - Load Effective Address
18 let neverHasSideEffects = 1 in
19 def LEA16r : I<0x8D, MRMSrcMem,
20 (outs GR16:$dst), (ins i32mem:$src),
21 "lea{w}\t{$src|$dst}, {$dst|$src}", []>, OpSize;
22 let isReMaterializable = 1 in
23 def LEA32r : I<0x8D, MRMSrcMem,
24 (outs GR32:$dst), (ins i32mem:$src),
25 "lea{l}\t{$src|$dst}, {$dst|$src}",
26 [(set GR32:$dst, lea32addr:$src)]>, Requires<[In32BitMode]>;
28 def LEA64_32r : I<0x8D, MRMSrcMem,
29 (outs GR32:$dst), (ins lea64_32mem:$src),
30 "lea{l}\t{$src|$dst}, {$dst|$src}",
31 [(set GR32:$dst, lea32addr:$src)]>, Requires<[In64BitMode]>;
33 let isReMaterializable = 1 in
34 def LEA64r : RI<0x8D, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
35 "lea{q}\t{$src|$dst}, {$dst|$src}",
36 [(set GR64:$dst, lea64addr:$src)]>;
40 //===----------------------------------------------------------------------===//
41 // Fixed-Register Multiplication and Division Instructions.
44 // Extra precision multiplication
46 // AL is really implied by AX, but the registers in Defs must match the
47 // SDNode results (i8, i32).
48 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
49 def MUL8r : I<0xF6, MRM4r, (outs), (ins GR8:$src), "mul{b}\t$src",
50 // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
51 // This probably ought to be moved to a def : Pat<> if the
52 // syntax can be accepted.
53 [(set AL, (mul AL, GR8:$src)),
54 (implicit EFLAGS)]>; // AL,AH = AL*GR8
56 let Defs = [AX,DX,EFLAGS], Uses = [AX], neverHasSideEffects = 1 in
57 def MUL16r : I<0xF7, MRM4r, (outs), (ins GR16:$src),
59 []>, OpSize; // AX,DX = AX*GR16
61 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX], neverHasSideEffects = 1 in
62 def MUL32r : I<0xF7, MRM4r, (outs), (ins GR32:$src),
64 []>; // EAX,EDX = EAX*GR32
66 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
67 def MUL8m : I<0xF6, MRM4m, (outs), (ins i8mem :$src),
69 // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
70 // This probably ought to be moved to a def : Pat<> if the
71 // syntax can be accepted.
72 [(set AL, (mul AL, (loadi8 addr:$src))),
73 (implicit EFLAGS)]>; // AL,AH = AL*[mem8]
75 let mayLoad = 1, neverHasSideEffects = 1 in {
76 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
77 def MUL16m : I<0xF7, MRM4m, (outs), (ins i16mem:$src),
79 []>, OpSize; // AX,DX = AX*[mem16]
81 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
82 def MUL32m : I<0xF7, MRM4m, (outs), (ins i32mem:$src),
84 []>; // EAX,EDX = EAX*[mem32]
87 let neverHasSideEffects = 1 in {
88 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
89 def IMUL8r : I<0xF6, MRM5r, (outs), (ins GR8:$src), "imul{b}\t$src", []>;
91 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
92 def IMUL16r : I<0xF7, MRM5r, (outs), (ins GR16:$src), "imul{w}\t$src", []>,
93 OpSize; // AX,DX = AX*GR16
94 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
95 def IMUL32r : I<0xF7, MRM5r, (outs), (ins GR32:$src), "imul{l}\t$src", []>;
98 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
99 def IMUL8m : I<0xF6, MRM5m, (outs), (ins i8mem :$src),
100 "imul{b}\t$src", []>; // AL,AH = AL*[mem8]
101 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
102 def IMUL16m : I<0xF7, MRM5m, (outs), (ins i16mem:$src),
103 "imul{w}\t$src", []>, OpSize; // AX,DX = AX*[mem16]
104 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
105 def IMUL32m : I<0xF7, MRM5m, (outs), (ins i32mem:$src),
106 "imul{l}\t$src", []>; // EAX,EDX = EAX*[mem32]
108 } // neverHasSideEffects
110 // unsigned division/remainder
111 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
112 def DIV8r : I<0xF6, MRM6r, (outs), (ins GR8:$src), // AX/r8 = AL,AH
114 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
115 def DIV16r : I<0xF7, MRM6r, (outs), (ins GR16:$src), // DX:AX/r16 = AX,DX
116 "div{w}\t$src", []>, OpSize;
117 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
118 def DIV32r : I<0xF7, MRM6r, (outs), (ins GR32:$src), // EDX:EAX/r32 = EAX,EDX
121 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
122 def DIV8m : I<0xF6, MRM6m, (outs), (ins i8mem:$src), // AX/[mem8] = AL,AH
124 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
125 def DIV16m : I<0xF7, MRM6m, (outs), (ins i16mem:$src), // DX:AX/[mem16] = AX,DX
126 "div{w}\t$src", []>, OpSize;
127 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
128 // EDX:EAX/[mem32] = EAX,EDX
129 def DIV32m : I<0xF7, MRM6m, (outs), (ins i32mem:$src),
133 // Signed division/remainder.
134 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
135 def IDIV8r : I<0xF6, MRM7r, (outs), (ins GR8:$src), // AX/r8 = AL,AH
136 "idiv{b}\t$src", []>;
137 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
138 def IDIV16r: I<0xF7, MRM7r, (outs), (ins GR16:$src), // DX:AX/r16 = AX,DX
139 "idiv{w}\t$src", []>, OpSize;
140 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
141 def IDIV32r: I<0xF7, MRM7r, (outs), (ins GR32:$src), // EDX:EAX/r32 = EAX,EDX
142 "idiv{l}\t$src", []>;
143 let mayLoad = 1, mayLoad = 1 in {
144 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
145 def IDIV8m : I<0xF6, MRM7m, (outs), (ins i8mem:$src), // AX/[mem8] = AL,AH
146 "idiv{b}\t$src", []>;
147 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
148 def IDIV16m: I<0xF7, MRM7m, (outs), (ins i16mem:$src), // DX:AX/[mem16] = AX,DX
149 "idiv{w}\t$src", []>, OpSize;
150 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
151 def IDIV32m: I<0xF7, MRM7m, (outs), (ins i32mem:$src),
152 // EDX:EAX/[mem32] = EAX,EDX
153 "idiv{l}\t$src", []>;
156 //===----------------------------------------------------------------------===//
157 // Two address Instructions.
160 // unary instructions
161 let CodeSize = 2 in {
162 let Defs = [EFLAGS] in {
163 let Constraints = "$src1 = $dst" in {
164 def NEG8r : I<0xF6, MRM3r, (outs GR8 :$dst), (ins GR8 :$src1),
166 [(set GR8:$dst, (ineg GR8:$src1)),
168 def NEG16r : I<0xF7, MRM3r, (outs GR16:$dst), (ins GR16:$src1),
170 [(set GR16:$dst, (ineg GR16:$src1)),
171 (implicit EFLAGS)]>, OpSize;
172 def NEG32r : I<0xF7, MRM3r, (outs GR32:$dst), (ins GR32:$src1),
174 [(set GR32:$dst, (ineg GR32:$src1)),
176 } // Constraints = "$src1 = $dst"
178 def NEG8m : I<0xF6, MRM3m, (outs), (ins i8mem :$dst),
180 [(store (ineg (loadi8 addr:$dst)), addr:$dst),
182 def NEG16m : I<0xF7, MRM3m, (outs), (ins i16mem:$dst),
184 [(store (ineg (loadi16 addr:$dst)), addr:$dst),
185 (implicit EFLAGS)]>, OpSize;
186 def NEG32m : I<0xF7, MRM3m, (outs), (ins i32mem:$dst),
188 [(store (ineg (loadi32 addr:$dst)), addr:$dst),
193 // FIXME: NOT sets EFLAGS!
195 let Constraints = "$src1 = $dst" in {
196 // Match xor -1 to not. Favors these over a move imm + xor to save code size.
197 let AddedComplexity = 15 in {
198 def NOT8r : I<0xF6, MRM2r, (outs GR8 :$dst), (ins GR8 :$src1),
200 [(set GR8:$dst, (not GR8:$src1))]>;
201 def NOT16r : I<0xF7, MRM2r, (outs GR16:$dst), (ins GR16:$src1),
203 [(set GR16:$dst, (not GR16:$src1))]>, OpSize;
204 def NOT32r : I<0xF7, MRM2r, (outs GR32:$dst), (ins GR32:$src1),
206 [(set GR32:$dst, (not GR32:$src1))]>;
208 } // Constraints = "$src1 = $dst"
210 def NOT8m : I<0xF6, MRM2m, (outs), (ins i8mem :$dst),
212 [(store (not (loadi8 addr:$dst)), addr:$dst)]>;
213 def NOT16m : I<0xF7, MRM2m, (outs), (ins i16mem:$dst),
215 [(store (not (loadi16 addr:$dst)), addr:$dst)]>, OpSize;
216 def NOT32m : I<0xF7, MRM2m, (outs), (ins i32mem:$dst),
218 [(store (not (loadi32 addr:$dst)), addr:$dst)]>;
221 // TODO: inc/dec is slow for P4, but fast for Pentium-M.
222 let Defs = [EFLAGS] in {
223 let Constraints = "$src1 = $dst" in {
225 def INC8r : I<0xFE, MRM0r, (outs GR8 :$dst), (ins GR8 :$src1),
227 [(set GR8:$dst, EFLAGS, (X86inc_flag GR8:$src1))]>;
229 let isConvertibleToThreeAddress = 1, CodeSize = 1 in { // Can xform into LEA.
230 def INC16r : I<0x40, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
232 [(set GR16:$dst, EFLAGS, (X86inc_flag GR16:$src1))]>,
233 OpSize, Requires<[In32BitMode]>;
234 def INC32r : I<0x40, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
236 [(set GR32:$dst, EFLAGS, (X86inc_flag GR32:$src1))]>,
237 Requires<[In32BitMode]>;
239 } // Constraints = "$src1 = $dst"
241 let CodeSize = 2 in {
242 def INC8m : I<0xFE, MRM0m, (outs), (ins i8mem :$dst), "inc{b}\t$dst",
243 [(store (add (loadi8 addr:$dst), 1), addr:$dst),
245 def INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
246 [(store (add (loadi16 addr:$dst), 1), addr:$dst),
248 OpSize, Requires<[In32BitMode]>;
249 def INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
250 [(store (add (loadi32 addr:$dst), 1), addr:$dst),
252 Requires<[In32BitMode]>;
255 let Constraints = "$src1 = $dst" in {
257 def DEC8r : I<0xFE, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
259 [(set GR8:$dst, EFLAGS, (X86dec_flag GR8:$src1))]>;
260 let isConvertibleToThreeAddress = 1, CodeSize = 1 in { // Can xform into LEA.
261 def DEC16r : I<0x48, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
263 [(set GR16:$dst, EFLAGS, (X86dec_flag GR16:$src1))]>,
264 OpSize, Requires<[In32BitMode]>;
265 def DEC32r : I<0x48, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
267 [(set GR32:$dst, EFLAGS, (X86dec_flag GR32:$src1))]>,
268 Requires<[In32BitMode]>;
270 } // Constraints = "$src1 = $dst"
273 let CodeSize = 2 in {
274 def DEC8m : I<0xFE, MRM1m, (outs), (ins i8mem :$dst), "dec{b}\t$dst",
275 [(store (add (loadi8 addr:$dst), -1), addr:$dst),
277 def DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
278 [(store (add (loadi16 addr:$dst), -1), addr:$dst),
280 OpSize, Requires<[In32BitMode]>;
281 def DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
282 [(store (add (loadi32 addr:$dst), -1), addr:$dst),
284 Requires<[In32BitMode]>;
288 // Logical operators.
289 let Defs = [EFLAGS] in {
290 let Constraints = "$src1 = $dst" in {
291 let isCommutable = 1 in { // X = AND Y, Z --> X = AND Z, Y
292 def AND8rr : I<0x20, MRMDestReg,
293 (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
294 "and{b}\t{$src2, $dst|$dst, $src2}",
295 [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1, GR8:$src2))]>;
296 def AND16rr : I<0x21, MRMDestReg,
297 (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
298 "and{w}\t{$src2, $dst|$dst, $src2}",
299 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
300 GR16:$src2))]>, OpSize;
301 def AND32rr : I<0x21, MRMDestReg,
302 (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
303 "and{l}\t{$src2, $dst|$dst, $src2}",
304 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
309 // AND instructions with the destination register in REG and the source register
310 // in R/M. Included for the disassembler.
311 let isCodeGenOnly = 1 in {
312 def AND8rr_REV : I<0x22, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
313 "and{b}\t{$src2, $dst|$dst, $src2}", []>;
314 def AND16rr_REV : I<0x23, MRMSrcReg, (outs GR16:$dst),
315 (ins GR16:$src1, GR16:$src2),
316 "and{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
317 def AND32rr_REV : I<0x23, MRMSrcReg, (outs GR32:$dst),
318 (ins GR32:$src1, GR32:$src2),
319 "and{l}\t{$src2, $dst|$dst, $src2}", []>;
322 def AND8rm : I<0x22, MRMSrcMem,
323 (outs GR8 :$dst), (ins GR8 :$src1, i8mem :$src2),
324 "and{b}\t{$src2, $dst|$dst, $src2}",
325 [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
326 (loadi8 addr:$src2)))]>;
327 def AND16rm : I<0x23, MRMSrcMem,
328 (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
329 "and{w}\t{$src2, $dst|$dst, $src2}",
330 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
331 (loadi16 addr:$src2)))]>,
333 def AND32rm : I<0x23, MRMSrcMem,
334 (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
335 "and{l}\t{$src2, $dst|$dst, $src2}",
336 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
337 (loadi32 addr:$src2)))]>;
339 def AND8ri : Ii8<0x80, MRM4r,
340 (outs GR8 :$dst), (ins GR8 :$src1, i8imm :$src2),
341 "and{b}\t{$src2, $dst|$dst, $src2}",
342 [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
344 def AND16ri : Ii16<0x81, MRM4r,
345 (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
346 "and{w}\t{$src2, $dst|$dst, $src2}",
347 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
348 imm:$src2))]>, OpSize;
349 def AND32ri : Ii32<0x81, MRM4r,
350 (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
351 "and{l}\t{$src2, $dst|$dst, $src2}",
352 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
354 def AND16ri8 : Ii8<0x83, MRM4r,
355 (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
356 "and{w}\t{$src2, $dst|$dst, $src2}",
357 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
358 i16immSExt8:$src2))]>,
360 def AND32ri8 : Ii8<0x83, MRM4r,
361 (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
362 "and{l}\t{$src2, $dst|$dst, $src2}",
363 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
364 i32immSExt8:$src2))]>;
365 } // Constraints = "$src1 = $dst"
367 def AND8mr : I<0x20, MRMDestMem,
368 (outs), (ins i8mem :$dst, GR8 :$src),
369 "and{b}\t{$src, $dst|$dst, $src}",
370 [(store (and (load addr:$dst), GR8:$src), addr:$dst),
372 def AND16mr : I<0x21, MRMDestMem,
373 (outs), (ins i16mem:$dst, GR16:$src),
374 "and{w}\t{$src, $dst|$dst, $src}",
375 [(store (and (load addr:$dst), GR16:$src), addr:$dst),
378 def AND32mr : I<0x21, MRMDestMem,
379 (outs), (ins i32mem:$dst, GR32:$src),
380 "and{l}\t{$src, $dst|$dst, $src}",
381 [(store (and (load addr:$dst), GR32:$src), addr:$dst),
383 def AND8mi : Ii8<0x80, MRM4m,
384 (outs), (ins i8mem :$dst, i8imm :$src),
385 "and{b}\t{$src, $dst|$dst, $src}",
386 [(store (and (loadi8 addr:$dst), imm:$src), addr:$dst),
388 def AND16mi : Ii16<0x81, MRM4m,
389 (outs), (ins i16mem:$dst, i16imm:$src),
390 "and{w}\t{$src, $dst|$dst, $src}",
391 [(store (and (loadi16 addr:$dst), imm:$src), addr:$dst),
394 def AND32mi : Ii32<0x81, MRM4m,
395 (outs), (ins i32mem:$dst, i32imm:$src),
396 "and{l}\t{$src, $dst|$dst, $src}",
397 [(store (and (loadi32 addr:$dst), imm:$src), addr:$dst),
399 def AND16mi8 : Ii8<0x83, MRM4m,
400 (outs), (ins i16mem:$dst, i16i8imm :$src),
401 "and{w}\t{$src, $dst|$dst, $src}",
402 [(store (and (load addr:$dst), i16immSExt8:$src), addr:$dst),
405 def AND32mi8 : Ii8<0x83, MRM4m,
406 (outs), (ins i32mem:$dst, i32i8imm :$src),
407 "and{l}\t{$src, $dst|$dst, $src}",
408 [(store (and (load addr:$dst), i32immSExt8:$src), addr:$dst),
411 // FIXME: Implicitly modifiers AL.
412 def AND8i8 : Ii8<0x24, RawFrm, (outs), (ins i8imm:$src),
413 "and{b}\t{$src, %al|%al, $src}", []>;
414 def AND16i16 : Ii16<0x25, RawFrm, (outs), (ins i16imm:$src),
415 "and{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
416 def AND32i32 : Ii32<0x25, RawFrm, (outs), (ins i32imm:$src),
417 "and{l}\t{$src, %eax|%eax, $src}", []>;
419 let Constraints = "$src1 = $dst" in {
421 let isCommutable = 1 in { // X = OR Y, Z --> X = OR Z, Y
422 def OR8rr : I<0x08, MRMDestReg, (outs GR8 :$dst),
423 (ins GR8 :$src1, GR8 :$src2),
424 "or{b}\t{$src2, $dst|$dst, $src2}",
425 [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1, GR8:$src2))]>;
426 def OR16rr : I<0x09, MRMDestReg, (outs GR16:$dst),
427 (ins GR16:$src1, GR16:$src2),
428 "or{w}\t{$src2, $dst|$dst, $src2}",
429 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,GR16:$src2))]>,
431 def OR32rr : I<0x09, MRMDestReg, (outs GR32:$dst),
432 (ins GR32:$src1, GR32:$src2),
433 "or{l}\t{$src2, $dst|$dst, $src2}",
434 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,GR32:$src2))]>;
437 // OR instructions with the destination register in REG and the source register
438 // in R/M. Included for the disassembler.
439 let isCodeGenOnly = 1 in {
440 def OR8rr_REV : I<0x0A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
441 "or{b}\t{$src2, $dst|$dst, $src2}", []>;
442 def OR16rr_REV : I<0x0B, MRMSrcReg, (outs GR16:$dst),
443 (ins GR16:$src1, GR16:$src2),
444 "or{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
445 def OR32rr_REV : I<0x0B, MRMSrcReg, (outs GR32:$dst),
446 (ins GR32:$src1, GR32:$src2),
447 "or{l}\t{$src2, $dst|$dst, $src2}", []>;
450 def OR8rm : I<0x0A, MRMSrcMem, (outs GR8 :$dst),
451 (ins GR8 :$src1, i8mem :$src2),
452 "or{b}\t{$src2, $dst|$dst, $src2}",
453 [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1,
454 (load addr:$src2)))]>;
455 def OR16rm : I<0x0B, MRMSrcMem, (outs GR16:$dst),
456 (ins GR16:$src1, i16mem:$src2),
457 "or{w}\t{$src2, $dst|$dst, $src2}",
458 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
459 (load addr:$src2)))]>,
461 def OR32rm : I<0x0B, MRMSrcMem, (outs GR32:$dst),
462 (ins GR32:$src1, i32mem:$src2),
463 "or{l}\t{$src2, $dst|$dst, $src2}",
464 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
465 (load addr:$src2)))]>;
467 def OR8ri : Ii8 <0x80, MRM1r, (outs GR8 :$dst),
468 (ins GR8 :$src1, i8imm:$src2),
469 "or{b}\t{$src2, $dst|$dst, $src2}",
470 [(set GR8:$dst,EFLAGS, (X86or_flag GR8:$src1, imm:$src2))]>;
471 def OR16ri : Ii16<0x81, MRM1r, (outs GR16:$dst),
472 (ins GR16:$src1, i16imm:$src2),
473 "or{w}\t{$src2, $dst|$dst, $src2}",
474 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
475 imm:$src2))]>, OpSize;
476 def OR32ri : Ii32<0x81, MRM1r, (outs GR32:$dst),
477 (ins GR32:$src1, i32imm:$src2),
478 "or{l}\t{$src2, $dst|$dst, $src2}",
479 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
482 def OR16ri8 : Ii8<0x83, MRM1r, (outs GR16:$dst),
483 (ins GR16:$src1, i16i8imm:$src2),
484 "or{w}\t{$src2, $dst|$dst, $src2}",
485 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
486 i16immSExt8:$src2))]>, OpSize;
487 def OR32ri8 : Ii8<0x83, MRM1r, (outs GR32:$dst),
488 (ins GR32:$src1, i32i8imm:$src2),
489 "or{l}\t{$src2, $dst|$dst, $src2}",
490 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
491 i32immSExt8:$src2))]>;
492 } // Constraints = "$src1 = $dst"
494 def OR8mr : I<0x08, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
495 "or{b}\t{$src, $dst|$dst, $src}",
496 [(store (or (load addr:$dst), GR8:$src), addr:$dst),
498 def OR16mr : I<0x09, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
499 "or{w}\t{$src, $dst|$dst, $src}",
500 [(store (or (load addr:$dst), GR16:$src), addr:$dst),
501 (implicit EFLAGS)]>, OpSize;
502 def OR32mr : I<0x09, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
503 "or{l}\t{$src, $dst|$dst, $src}",
504 [(store (or (load addr:$dst), GR32:$src), addr:$dst),
506 def OR8mi : Ii8<0x80, MRM1m, (outs), (ins i8mem :$dst, i8imm:$src),
507 "or{b}\t{$src, $dst|$dst, $src}",
508 [(store (or (loadi8 addr:$dst), imm:$src), addr:$dst),
510 def OR16mi : Ii16<0x81, MRM1m, (outs), (ins i16mem:$dst, i16imm:$src),
511 "or{w}\t{$src, $dst|$dst, $src}",
512 [(store (or (loadi16 addr:$dst), imm:$src), addr:$dst),
515 def OR32mi : Ii32<0x81, MRM1m, (outs), (ins i32mem:$dst, i32imm:$src),
516 "or{l}\t{$src, $dst|$dst, $src}",
517 [(store (or (loadi32 addr:$dst), imm:$src), addr:$dst),
519 def OR16mi8 : Ii8<0x83, MRM1m, (outs), (ins i16mem:$dst, i16i8imm:$src),
520 "or{w}\t{$src, $dst|$dst, $src}",
521 [(store (or (load addr:$dst), i16immSExt8:$src), addr:$dst),
524 def OR32mi8 : Ii8<0x83, MRM1m, (outs), (ins i32mem:$dst, i32i8imm:$src),
525 "or{l}\t{$src, $dst|$dst, $src}",
526 [(store (or (load addr:$dst), i32immSExt8:$src), addr:$dst),
529 def OR8i8 : Ii8 <0x0C, RawFrm, (outs), (ins i8imm:$src),
530 "or{b}\t{$src, %al|%al, $src}", []>;
531 def OR16i16 : Ii16 <0x0D, RawFrm, (outs), (ins i16imm:$src),
532 "or{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
533 def OR32i32 : Ii32 <0x0D, RawFrm, (outs), (ins i32imm:$src),
534 "or{l}\t{$src, %eax|%eax, $src}", []>;
537 let Constraints = "$src1 = $dst" in {
539 let isCommutable = 1 in { // X = XOR Y, Z --> X = XOR Z, Y
540 def XOR8rr : I<0x30, MRMDestReg,
541 (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
542 "xor{b}\t{$src2, $dst|$dst, $src2}",
543 [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
545 def XOR16rr : I<0x31, MRMDestReg,
546 (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
547 "xor{w}\t{$src2, $dst|$dst, $src2}",
548 [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
549 GR16:$src2))]>, OpSize;
550 def XOR32rr : I<0x31, MRMDestReg,
551 (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
552 "xor{l}\t{$src2, $dst|$dst, $src2}",
553 [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
555 } // isCommutable = 1
557 // XOR instructions with the destination register in REG and the source register
558 // in R/M. Included for the disassembler.
559 let isCodeGenOnly = 1 in {
560 def XOR8rr_REV : I<0x32, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
561 "xor{b}\t{$src2, $dst|$dst, $src2}", []>;
562 def XOR16rr_REV : I<0x33, MRMSrcReg, (outs GR16:$dst),
563 (ins GR16:$src1, GR16:$src2),
564 "xor{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
565 def XOR32rr_REV : I<0x33, MRMSrcReg, (outs GR32:$dst),
566 (ins GR32:$src1, GR32:$src2),
567 "xor{l}\t{$src2, $dst|$dst, $src2}", []>;
570 def XOR8rm : I<0x32, MRMSrcMem,
571 (outs GR8 :$dst), (ins GR8:$src1, i8mem :$src2),
572 "xor{b}\t{$src2, $dst|$dst, $src2}",
573 [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
574 (load addr:$src2)))]>;
575 def XOR16rm : I<0x33, MRMSrcMem,
576 (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
577 "xor{w}\t{$src2, $dst|$dst, $src2}",
578 [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
579 (load addr:$src2)))]>,
581 def XOR32rm : I<0x33, MRMSrcMem,
582 (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
583 "xor{l}\t{$src2, $dst|$dst, $src2}",
584 [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
585 (load addr:$src2)))]>;
587 def XOR8ri : Ii8<0x80, MRM6r,
588 (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
589 "xor{b}\t{$src2, $dst|$dst, $src2}",
590 [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1, imm:$src2))]>;
591 def XOR16ri : Ii16<0x81, MRM6r,
592 (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
593 "xor{w}\t{$src2, $dst|$dst, $src2}",
594 [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
595 imm:$src2))]>, OpSize;
596 def XOR32ri : Ii32<0x81, MRM6r,
597 (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
598 "xor{l}\t{$src2, $dst|$dst, $src2}",
599 [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
601 def XOR16ri8 : Ii8<0x83, MRM6r,
602 (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
603 "xor{w}\t{$src2, $dst|$dst, $src2}",
604 [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
605 i16immSExt8:$src2))]>,
607 def XOR32ri8 : Ii8<0x83, MRM6r,
608 (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
609 "xor{l}\t{$src2, $dst|$dst, $src2}",
610 [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
611 i32immSExt8:$src2))]>;
612 } // Constraints = "$src1 = $dst"
615 def XOR8mr : I<0x30, MRMDestMem,
616 (outs), (ins i8mem :$dst, GR8 :$src),
617 "xor{b}\t{$src, $dst|$dst, $src}",
618 [(store (xor (load addr:$dst), GR8:$src), addr:$dst),
620 def XOR16mr : I<0x31, MRMDestMem,
621 (outs), (ins i16mem:$dst, GR16:$src),
622 "xor{w}\t{$src, $dst|$dst, $src}",
623 [(store (xor (load addr:$dst), GR16:$src), addr:$dst),
626 def XOR32mr : I<0x31, MRMDestMem,
627 (outs), (ins i32mem:$dst, GR32:$src),
628 "xor{l}\t{$src, $dst|$dst, $src}",
629 [(store (xor (load addr:$dst), GR32:$src), addr:$dst),
631 def XOR8mi : Ii8<0x80, MRM6m,
632 (outs), (ins i8mem :$dst, i8imm :$src),
633 "xor{b}\t{$src, $dst|$dst, $src}",
634 [(store (xor (loadi8 addr:$dst), imm:$src), addr:$dst),
636 def XOR16mi : Ii16<0x81, MRM6m,
637 (outs), (ins i16mem:$dst, i16imm:$src),
638 "xor{w}\t{$src, $dst|$dst, $src}",
639 [(store (xor (loadi16 addr:$dst), imm:$src), addr:$dst),
642 def XOR32mi : Ii32<0x81, MRM6m,
643 (outs), (ins i32mem:$dst, i32imm:$src),
644 "xor{l}\t{$src, $dst|$dst, $src}",
645 [(store (xor (loadi32 addr:$dst), imm:$src), addr:$dst),
647 def XOR16mi8 : Ii8<0x83, MRM6m,
648 (outs), (ins i16mem:$dst, i16i8imm :$src),
649 "xor{w}\t{$src, $dst|$dst, $src}",
650 [(store (xor (load addr:$dst), i16immSExt8:$src), addr:$dst),
653 def XOR32mi8 : Ii8<0x83, MRM6m,
654 (outs), (ins i32mem:$dst, i32i8imm :$src),
655 "xor{l}\t{$src, $dst|$dst, $src}",
656 [(store (xor (load addr:$dst), i32immSExt8:$src), addr:$dst),
659 def XOR8i8 : Ii8 <0x34, RawFrm, (outs), (ins i8imm:$src),
660 "xor{b}\t{$src, %al|%al, $src}", []>;
661 def XOR16i16 : Ii16<0x35, RawFrm, (outs), (ins i16imm:$src),
662 "xor{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
663 def XOR32i32 : Ii32<0x35, RawFrm, (outs), (ins i32imm:$src),
664 "xor{l}\t{$src, %eax|%eax, $src}", []>;
669 let Defs = [EFLAGS] in {
670 let Constraints = "$src1 = $dst" in {
671 let isCommutable = 1 in { // X = ADD Y, Z --> X = ADD Z, Y
672 // Register-Register Addition
673 def ADD8rr : I<0x00, MRMDestReg, (outs GR8 :$dst),
674 (ins GR8 :$src1, GR8 :$src2),
675 "add{b}\t{$src2, $dst|$dst, $src2}",
676 [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1, GR8:$src2))]>;
678 let isConvertibleToThreeAddress = 1 in { // Can transform into LEA.
679 // Register-Register Addition
680 def ADD16rr : I<0x01, MRMDestReg, (outs GR16:$dst),
681 (ins GR16:$src1, GR16:$src2),
682 "add{w}\t{$src2, $dst|$dst, $src2}",
683 [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
684 GR16:$src2))]>, OpSize;
685 def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst),
686 (ins GR32:$src1, GR32:$src2),
687 "add{l}\t{$src2, $dst|$dst, $src2}",
688 [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
690 } // end isConvertibleToThreeAddress
691 } // end isCommutable
693 // These are alternate spellings for use by the disassembler, we mark them as
694 // code gen only to ensure they aren't matched by the assembler.
695 let isCodeGenOnly = 1 in {
696 def ADD8rr_alt: I<0x02, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
697 "add{b}\t{$src2, $dst|$dst, $src2}", []>;
698 def ADD16rr_alt: I<0x03, MRMSrcReg,(outs GR16:$dst),(ins GR16:$src1, GR16:$src2),
699 "add{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
700 def ADD32rr_alt: I<0x03, MRMSrcReg,(outs GR32:$dst),(ins GR32:$src1, GR32:$src2),
701 "add{l}\t{$src2, $dst|$dst, $src2}", []>;
704 // Register-Memory Addition
705 def ADD8rm : I<0x02, MRMSrcMem, (outs GR8 :$dst),
706 (ins GR8 :$src1, i8mem :$src2),
707 "add{b}\t{$src2, $dst|$dst, $src2}",
708 [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1,
709 (load addr:$src2)))]>;
710 def ADD16rm : I<0x03, MRMSrcMem, (outs GR16:$dst),
711 (ins GR16:$src1, i16mem:$src2),
712 "add{w}\t{$src2, $dst|$dst, $src2}",
713 [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
714 (load addr:$src2)))]>, OpSize;
715 def ADD32rm : I<0x03, MRMSrcMem, (outs GR32:$dst),
716 (ins GR32:$src1, i32mem:$src2),
717 "add{l}\t{$src2, $dst|$dst, $src2}",
718 [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
719 (load addr:$src2)))]>;
721 // Register-Integer Addition
722 def ADD8ri : Ii8<0x80, MRM0r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
723 "add{b}\t{$src2, $dst|$dst, $src2}",
724 [(set GR8:$dst, EFLAGS,
725 (X86add_flag GR8:$src1, imm:$src2))]>;
727 let isConvertibleToThreeAddress = 1 in { // Can transform into LEA.
728 // Register-Integer Addition
729 def ADD16ri : Ii16<0x81, MRM0r, (outs GR16:$dst),
730 (ins GR16:$src1, i16imm:$src2),
731 "add{w}\t{$src2, $dst|$dst, $src2}",
732 [(set GR16:$dst, EFLAGS,
733 (X86add_flag GR16:$src1, imm:$src2))]>, OpSize;
734 def ADD32ri : Ii32<0x81, MRM0r, (outs GR32:$dst),
735 (ins GR32:$src1, i32imm:$src2),
736 "add{l}\t{$src2, $dst|$dst, $src2}",
737 [(set GR32:$dst, EFLAGS,
738 (X86add_flag GR32:$src1, imm:$src2))]>;
739 def ADD16ri8 : Ii8<0x83, MRM0r, (outs GR16:$dst),
740 (ins GR16:$src1, i16i8imm:$src2),
741 "add{w}\t{$src2, $dst|$dst, $src2}",
742 [(set GR16:$dst, EFLAGS,
743 (X86add_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
744 def ADD32ri8 : Ii8<0x83, MRM0r, (outs GR32:$dst),
745 (ins GR32:$src1, i32i8imm:$src2),
746 "add{l}\t{$src2, $dst|$dst, $src2}",
747 [(set GR32:$dst, EFLAGS,
748 (X86add_flag GR32:$src1, i32immSExt8:$src2))]>;
750 } // Constraints = "$src1 = $dst"
752 // Memory-Register Addition
753 def ADD8mr : I<0x00, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
754 "add{b}\t{$src2, $dst|$dst, $src2}",
755 [(store (add (load addr:$dst), GR8:$src2), addr:$dst),
757 def ADD16mr : I<0x01, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
758 "add{w}\t{$src2, $dst|$dst, $src2}",
759 [(store (add (load addr:$dst), GR16:$src2), addr:$dst),
760 (implicit EFLAGS)]>, OpSize;
761 def ADD32mr : I<0x01, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
762 "add{l}\t{$src2, $dst|$dst, $src2}",
763 [(store (add (load addr:$dst), GR32:$src2), addr:$dst),
765 def ADD8mi : Ii8<0x80, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src2),
766 "add{b}\t{$src2, $dst|$dst, $src2}",
767 [(store (add (loadi8 addr:$dst), imm:$src2), addr:$dst),
769 def ADD16mi : Ii16<0x81, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src2),
770 "add{w}\t{$src2, $dst|$dst, $src2}",
771 [(store (add (loadi16 addr:$dst), imm:$src2), addr:$dst),
772 (implicit EFLAGS)]>, OpSize;
773 def ADD32mi : Ii32<0x81, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src2),
774 "add{l}\t{$src2, $dst|$dst, $src2}",
775 [(store (add (loadi32 addr:$dst), imm:$src2), addr:$dst),
777 def ADD16mi8 : Ii8<0x83, MRM0m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
778 "add{w}\t{$src2, $dst|$dst, $src2}",
779 [(store (add (load addr:$dst), i16immSExt8:$src2),
781 (implicit EFLAGS)]>, OpSize;
782 def ADD32mi8 : Ii8<0x83, MRM0m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
783 "add{l}\t{$src2, $dst|$dst, $src2}",
784 [(store (add (load addr:$dst), i32immSExt8:$src2),
789 def ADD8i8 : Ii8<0x04, RawFrm, (outs), (ins i8imm:$src),
790 "add{b}\t{$src, %al|%al, $src}", []>;
791 def ADD16i16 : Ii16<0x05, RawFrm, (outs), (ins i16imm:$src),
792 "add{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
793 def ADD32i32 : Ii32<0x05, RawFrm, (outs), (ins i32imm:$src),
794 "add{l}\t{$src, %eax|%eax, $src}", []>;
796 let Uses = [EFLAGS] in {
797 let Constraints = "$src1 = $dst" in {
798 let isCommutable = 1 in { // X = ADC Y, Z --> X = ADC Z, Y
799 def ADC8rr : I<0x10, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
800 "adc{b}\t{$src2, $dst|$dst, $src2}",
801 [(set GR8:$dst, (adde GR8:$src1, GR8:$src2))]>;
802 def ADC16rr : I<0x11, MRMDestReg, (outs GR16:$dst),
803 (ins GR16:$src1, GR16:$src2),
804 "adc{w}\t{$src2, $dst|$dst, $src2}",
805 [(set GR16:$dst, (adde GR16:$src1, GR16:$src2))]>, OpSize;
806 def ADC32rr : I<0x11, MRMDestReg, (outs GR32:$dst),
807 (ins GR32:$src1, GR32:$src2),
808 "adc{l}\t{$src2, $dst|$dst, $src2}",
809 [(set GR32:$dst, (adde GR32:$src1, GR32:$src2))]>;
812 let isCodeGenOnly = 1 in {
813 def ADC8rr_REV : I<0x12, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
814 "adc{b}\t{$src2, $dst|$dst, $src2}", []>;
815 def ADC16rr_REV : I<0x13, MRMSrcReg, (outs GR16:$dst),
816 (ins GR16:$src1, GR16:$src2),
817 "adc{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
818 def ADC32rr_REV : I<0x13, MRMSrcReg, (outs GR32:$dst),
819 (ins GR32:$src1, GR32:$src2),
820 "adc{l}\t{$src2, $dst|$dst, $src2}", []>;
823 def ADC8rm : I<0x12, MRMSrcMem , (outs GR8:$dst),
824 (ins GR8:$src1, i8mem:$src2),
825 "adc{b}\t{$src2, $dst|$dst, $src2}",
826 [(set GR8:$dst, (adde GR8:$src1, (load addr:$src2)))]>;
827 def ADC16rm : I<0x13, MRMSrcMem , (outs GR16:$dst),
828 (ins GR16:$src1, i16mem:$src2),
829 "adc{w}\t{$src2, $dst|$dst, $src2}",
830 [(set GR16:$dst, (adde GR16:$src1, (load addr:$src2)))]>,
832 def ADC32rm : I<0x13, MRMSrcMem , (outs GR32:$dst),
833 (ins GR32:$src1, i32mem:$src2),
834 "adc{l}\t{$src2, $dst|$dst, $src2}",
835 [(set GR32:$dst, (adde GR32:$src1, (load addr:$src2)))]>;
836 def ADC8ri : Ii8<0x80, MRM2r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
837 "adc{b}\t{$src2, $dst|$dst, $src2}",
838 [(set GR8:$dst, (adde GR8:$src1, imm:$src2))]>;
839 def ADC16ri : Ii16<0x81, MRM2r, (outs GR16:$dst),
840 (ins GR16:$src1, i16imm:$src2),
841 "adc{w}\t{$src2, $dst|$dst, $src2}",
842 [(set GR16:$dst, (adde GR16:$src1, imm:$src2))]>, OpSize;
843 def ADC16ri8 : Ii8<0x83, MRM2r, (outs GR16:$dst),
844 (ins GR16:$src1, i16i8imm:$src2),
845 "adc{w}\t{$src2, $dst|$dst, $src2}",
846 [(set GR16:$dst, (adde GR16:$src1, i16immSExt8:$src2))]>,
848 def ADC32ri : Ii32<0x81, MRM2r, (outs GR32:$dst),
849 (ins GR32:$src1, i32imm:$src2),
850 "adc{l}\t{$src2, $dst|$dst, $src2}",
851 [(set GR32:$dst, (adde GR32:$src1, imm:$src2))]>;
852 def ADC32ri8 : Ii8<0x83, MRM2r, (outs GR32:$dst),
853 (ins GR32:$src1, i32i8imm:$src2),
854 "adc{l}\t{$src2, $dst|$dst, $src2}",
855 [(set GR32:$dst, (adde GR32:$src1, i32immSExt8:$src2))]>;
856 } // Constraints = "$src1 = $dst"
858 def ADC8mr : I<0x10, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
859 "adc{b}\t{$src2, $dst|$dst, $src2}",
860 [(store (adde (load addr:$dst), GR8:$src2), addr:$dst)]>;
861 def ADC16mr : I<0x11, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
862 "adc{w}\t{$src2, $dst|$dst, $src2}",
863 [(store (adde (load addr:$dst), GR16:$src2), addr:$dst)]>,
865 def ADC32mr : I<0x11, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
866 "adc{l}\t{$src2, $dst|$dst, $src2}",
867 [(store (adde (load addr:$dst), GR32:$src2), addr:$dst)]>;
868 def ADC8mi : Ii8<0x80, MRM2m, (outs), (ins i8mem:$dst, i8imm:$src2),
869 "adc{b}\t{$src2, $dst|$dst, $src2}",
870 [(store (adde (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
871 def ADC16mi : Ii16<0x81, MRM2m, (outs), (ins i16mem:$dst, i16imm:$src2),
872 "adc{w}\t{$src2, $dst|$dst, $src2}",
873 [(store (adde (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
875 def ADC16mi8 : Ii8<0x83, MRM2m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
876 "adc{w}\t{$src2, $dst|$dst, $src2}",
877 [(store (adde (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
879 def ADC32mi : Ii32<0x81, MRM2m, (outs), (ins i32mem:$dst, i32imm:$src2),
880 "adc{l}\t{$src2, $dst|$dst, $src2}",
881 [(store (adde (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
882 def ADC32mi8 : Ii8<0x83, MRM2m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
883 "adc{l}\t{$src2, $dst|$dst, $src2}",
884 [(store (adde (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
886 def ADC8i8 : Ii8<0x14, RawFrm, (outs), (ins i8imm:$src),
887 "adc{b}\t{$src, %al|%al, $src}", []>;
888 def ADC16i16 : Ii16<0x15, RawFrm, (outs), (ins i16imm:$src),
889 "adc{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
890 def ADC32i32 : Ii32<0x15, RawFrm, (outs), (ins i32imm:$src),
891 "adc{l}\t{$src, %eax|%eax, $src}", []>;
894 let Constraints = "$src1 = $dst" in {
896 // Register-Register Subtraction
897 def SUB8rr : I<0x28, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
898 "sub{b}\t{$src2, $dst|$dst, $src2}",
899 [(set GR8:$dst, EFLAGS,
900 (X86sub_flag GR8:$src1, GR8:$src2))]>;
901 def SUB16rr : I<0x29, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
902 "sub{w}\t{$src2, $dst|$dst, $src2}",
903 [(set GR16:$dst, EFLAGS,
904 (X86sub_flag GR16:$src1, GR16:$src2))]>, OpSize;
905 def SUB32rr : I<0x29, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
906 "sub{l}\t{$src2, $dst|$dst, $src2}",
907 [(set GR32:$dst, EFLAGS,
908 (X86sub_flag GR32:$src1, GR32:$src2))]>;
910 let isCodeGenOnly = 1 in {
911 def SUB8rr_REV : I<0x2A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
912 "sub{b}\t{$src2, $dst|$dst, $src2}", []>;
913 def SUB16rr_REV : I<0x2B, MRMSrcReg, (outs GR16:$dst),
914 (ins GR16:$src1, GR16:$src2),
915 "sub{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
916 def SUB32rr_REV : I<0x2B, MRMSrcReg, (outs GR32:$dst),
917 (ins GR32:$src1, GR32:$src2),
918 "sub{l}\t{$src2, $dst|$dst, $src2}", []>;
921 // Register-Memory Subtraction
922 def SUB8rm : I<0x2A, MRMSrcMem, (outs GR8 :$dst),
923 (ins GR8 :$src1, i8mem :$src2),
924 "sub{b}\t{$src2, $dst|$dst, $src2}",
925 [(set GR8:$dst, EFLAGS,
926 (X86sub_flag GR8:$src1, (load addr:$src2)))]>;
927 def SUB16rm : I<0x2B, MRMSrcMem, (outs GR16:$dst),
928 (ins GR16:$src1, i16mem:$src2),
929 "sub{w}\t{$src2, $dst|$dst, $src2}",
930 [(set GR16:$dst, EFLAGS,
931 (X86sub_flag GR16:$src1, (load addr:$src2)))]>, OpSize;
932 def SUB32rm : I<0x2B, MRMSrcMem, (outs GR32:$dst),
933 (ins GR32:$src1, i32mem:$src2),
934 "sub{l}\t{$src2, $dst|$dst, $src2}",
935 [(set GR32:$dst, EFLAGS,
936 (X86sub_flag GR32:$src1, (load addr:$src2)))]>;
938 // Register-Integer Subtraction
939 def SUB8ri : Ii8 <0x80, MRM5r, (outs GR8:$dst),
940 (ins GR8:$src1, i8imm:$src2),
941 "sub{b}\t{$src2, $dst|$dst, $src2}",
942 [(set GR8:$dst, EFLAGS,
943 (X86sub_flag GR8:$src1, imm:$src2))]>;
944 def SUB16ri : Ii16<0x81, MRM5r, (outs GR16:$dst),
945 (ins GR16:$src1, i16imm:$src2),
946 "sub{w}\t{$src2, $dst|$dst, $src2}",
947 [(set GR16:$dst, EFLAGS,
948 (X86sub_flag GR16:$src1, imm:$src2))]>, OpSize;
949 def SUB32ri : Ii32<0x81, MRM5r, (outs GR32:$dst),
950 (ins GR32:$src1, i32imm:$src2),
951 "sub{l}\t{$src2, $dst|$dst, $src2}",
952 [(set GR32:$dst, EFLAGS,
953 (X86sub_flag GR32:$src1, imm:$src2))]>;
954 def SUB16ri8 : Ii8<0x83, MRM5r, (outs GR16:$dst),
955 (ins GR16:$src1, i16i8imm:$src2),
956 "sub{w}\t{$src2, $dst|$dst, $src2}",
957 [(set GR16:$dst, EFLAGS,
958 (X86sub_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
959 def SUB32ri8 : Ii8<0x83, MRM5r, (outs GR32:$dst),
960 (ins GR32:$src1, i32i8imm:$src2),
961 "sub{l}\t{$src2, $dst|$dst, $src2}",
962 [(set GR32:$dst, EFLAGS,
963 (X86sub_flag GR32:$src1, i32immSExt8:$src2))]>;
964 } // Constraints = "$src1 = $dst"
966 // Memory-Register Subtraction
967 def SUB8mr : I<0x28, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src2),
968 "sub{b}\t{$src2, $dst|$dst, $src2}",
969 [(store (sub (load addr:$dst), GR8:$src2), addr:$dst),
971 def SUB16mr : I<0x29, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
972 "sub{w}\t{$src2, $dst|$dst, $src2}",
973 [(store (sub (load addr:$dst), GR16:$src2), addr:$dst),
974 (implicit EFLAGS)]>, OpSize;
975 def SUB32mr : I<0x29, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
976 "sub{l}\t{$src2, $dst|$dst, $src2}",
977 [(store (sub (load addr:$dst), GR32:$src2), addr:$dst),
980 // Memory-Integer Subtraction
981 def SUB8mi : Ii8<0x80, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src2),
982 "sub{b}\t{$src2, $dst|$dst, $src2}",
983 [(store (sub (loadi8 addr:$dst), imm:$src2), addr:$dst),
985 def SUB16mi : Ii16<0x81, MRM5m, (outs), (ins i16mem:$dst, i16imm:$src2),
986 "sub{w}\t{$src2, $dst|$dst, $src2}",
987 [(store (sub (loadi16 addr:$dst), imm:$src2),addr:$dst),
988 (implicit EFLAGS)]>, OpSize;
989 def SUB32mi : Ii32<0x81, MRM5m, (outs), (ins i32mem:$dst, i32imm:$src2),
990 "sub{l}\t{$src2, $dst|$dst, $src2}",
991 [(store (sub (loadi32 addr:$dst), imm:$src2),addr:$dst),
993 def SUB16mi8 : Ii8<0x83, MRM5m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
994 "sub{w}\t{$src2, $dst|$dst, $src2}",
995 [(store (sub (load addr:$dst), i16immSExt8:$src2),
997 (implicit EFLAGS)]>, OpSize;
998 def SUB32mi8 : Ii8<0x83, MRM5m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
999 "sub{l}\t{$src2, $dst|$dst, $src2}",
1000 [(store (sub (load addr:$dst), i32immSExt8:$src2),
1002 (implicit EFLAGS)]>;
1004 def SUB8i8 : Ii8<0x2C, RawFrm, (outs), (ins i8imm:$src),
1005 "sub{b}\t{$src, %al|%al, $src}", []>;
1006 def SUB16i16 : Ii16<0x2D, RawFrm, (outs), (ins i16imm:$src),
1007 "sub{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1008 def SUB32i32 : Ii32<0x2D, RawFrm, (outs), (ins i32imm:$src),
1009 "sub{l}\t{$src, %eax|%eax, $src}", []>;
1011 let Uses = [EFLAGS] in {
1012 let Constraints = "$src1 = $dst" in {
1013 def SBB8rr : I<0x18, MRMDestReg, (outs GR8:$dst),
1014 (ins GR8:$src1, GR8:$src2),
1015 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1016 [(set GR8:$dst, (sube GR8:$src1, GR8:$src2))]>;
1017 def SBB16rr : I<0x19, MRMDestReg, (outs GR16:$dst),
1018 (ins GR16:$src1, GR16:$src2),
1019 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1020 [(set GR16:$dst, (sube GR16:$src1, GR16:$src2))]>, OpSize;
1021 def SBB32rr : I<0x19, MRMDestReg, (outs GR32:$dst),
1022 (ins GR32:$src1, GR32:$src2),
1023 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1024 [(set GR32:$dst, (sube GR32:$src1, GR32:$src2))]>;
1025 } // Constraints = "$src1 = $dst"
1028 def SBB8mr : I<0x18, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1029 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1030 [(store (sube (load addr:$dst), GR8:$src2), addr:$dst)]>;
1031 def SBB16mr : I<0x19, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1032 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1033 [(store (sube (load addr:$dst), GR16:$src2), addr:$dst)]>,
1035 def SBB32mr : I<0x19, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1036 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1037 [(store (sube (load addr:$dst), GR32:$src2), addr:$dst)]>;
1038 def SBB8mi : Ii8<0x80, MRM3m, (outs), (ins i8mem:$dst, i8imm:$src2),
1039 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1040 [(store (sube (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1041 def SBB16mi : Ii16<0x81, MRM3m, (outs), (ins i16mem:$dst, i16imm:$src2),
1042 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1043 [(store (sube (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1045 def SBB16mi8 : Ii8<0x83, MRM3m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1046 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1047 [(store (sube (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1049 def SBB32mi : Ii32<0x81, MRM3m, (outs), (ins i32mem:$dst, i32imm:$src2),
1050 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1051 [(store (sube (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1052 def SBB32mi8 : Ii8<0x83, MRM3m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1053 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1054 [(store (sube (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1056 def SBB8i8 : Ii8<0x1C, RawFrm, (outs), (ins i8imm:$src),
1057 "sbb{b}\t{$src, %al|%al, $src}", []>;
1058 def SBB16i16 : Ii16<0x1D, RawFrm, (outs), (ins i16imm:$src),
1059 "sbb{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1060 def SBB32i32 : Ii32<0x1D, RawFrm, (outs), (ins i32imm:$src),
1061 "sbb{l}\t{$src, %eax|%eax, $src}", []>;
1063 let Constraints = "$src1 = $dst" in {
1065 let isCodeGenOnly = 1 in {
1066 def SBB8rr_REV : I<0x1A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1067 "sbb{b}\t{$src2, $dst|$dst, $src2}", []>;
1068 def SBB16rr_REV : I<0x1B, MRMSrcReg, (outs GR16:$dst),
1069 (ins GR16:$src1, GR16:$src2),
1070 "sbb{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1071 def SBB32rr_REV : I<0x1B, MRMSrcReg, (outs GR32:$dst),
1072 (ins GR32:$src1, GR32:$src2),
1073 "sbb{l}\t{$src2, $dst|$dst, $src2}", []>;
1076 def SBB8rm : I<0x1A, MRMSrcMem, (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1077 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1078 [(set GR8:$dst, (sube GR8:$src1, (load addr:$src2)))]>;
1079 def SBB16rm : I<0x1B, MRMSrcMem, (outs GR16:$dst),
1080 (ins GR16:$src1, i16mem:$src2),
1081 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1082 [(set GR16:$dst, (sube GR16:$src1, (load addr:$src2)))]>,
1084 def SBB32rm : I<0x1B, MRMSrcMem, (outs GR32:$dst),
1085 (ins GR32:$src1, i32mem:$src2),
1086 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1087 [(set GR32:$dst, (sube GR32:$src1, (load addr:$src2)))]>;
1088 def SBB8ri : Ii8<0x80, MRM3r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1089 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1090 [(set GR8:$dst, (sube GR8:$src1, imm:$src2))]>;
1091 def SBB16ri : Ii16<0x81, MRM3r, (outs GR16:$dst),
1092 (ins GR16:$src1, i16imm:$src2),
1093 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1094 [(set GR16:$dst, (sube GR16:$src1, imm:$src2))]>, OpSize;
1095 def SBB16ri8 : Ii8<0x83, MRM3r, (outs GR16:$dst),
1096 (ins GR16:$src1, i16i8imm:$src2),
1097 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1098 [(set GR16:$dst, (sube GR16:$src1, i16immSExt8:$src2))]>,
1100 def SBB32ri : Ii32<0x81, MRM3r, (outs GR32:$dst),
1101 (ins GR32:$src1, i32imm:$src2),
1102 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1103 [(set GR32:$dst, (sube GR32:$src1, imm:$src2))]>;
1104 def SBB32ri8 : Ii8<0x83, MRM3r, (outs GR32:$dst),
1105 (ins GR32:$src1, i32i8imm:$src2),
1106 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1107 [(set GR32:$dst, (sube GR32:$src1, i32immSExt8:$src2))]>;
1108 } // Constraints = "$src1 = $dst"
1110 } // Uses = [EFLAGS]
1111 } // Defs = [EFLAGS]
1113 let Defs = [EFLAGS] in {
1114 let Constraints = "$src1 = $dst" in {
1116 let isCommutable = 1 in { // X = IMUL Y, Z --> X = IMUL Z, Y
1117 // Register-Register Signed Integer Multiply
1118 def IMUL16rr : I<0xAF, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
1119 "imul{w}\t{$src2, $dst|$dst, $src2}",
1120 [(set GR16:$dst, EFLAGS,
1121 (X86smul_flag GR16:$src1, GR16:$src2))]>, TB, OpSize;
1122 def IMUL32rr : I<0xAF, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
1123 "imul{l}\t{$src2, $dst|$dst, $src2}",
1124 [(set GR32:$dst, EFLAGS,
1125 (X86smul_flag GR32:$src1, GR32:$src2))]>, TB;
1128 // Register-Memory Signed Integer Multiply
1129 def IMUL16rm : I<0xAF, MRMSrcMem, (outs GR16:$dst),
1130 (ins GR16:$src1, i16mem:$src2),
1131 "imul{w}\t{$src2, $dst|$dst, $src2}",
1132 [(set GR16:$dst, EFLAGS,
1133 (X86smul_flag GR16:$src1, (load addr:$src2)))]>,
1135 def IMUL32rm : I<0xAF, MRMSrcMem, (outs GR32:$dst),
1136 (ins GR32:$src1, i32mem:$src2),
1137 "imul{l}\t{$src2, $dst|$dst, $src2}",
1138 [(set GR32:$dst, EFLAGS,
1139 (X86smul_flag GR32:$src1, (load addr:$src2)))]>, TB;
1140 } // Constraints = "$src1 = $dst"
1142 } // Defs = [EFLAGS]
1144 // Suprisingly enough, these are not two address instructions!
1145 let Defs = [EFLAGS] in {
1146 // Register-Integer Signed Integer Multiply
1147 def IMUL16rri : Ii16<0x69, MRMSrcReg, // GR16 = GR16*I16
1148 (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
1149 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1150 [(set GR16:$dst, EFLAGS,
1151 (X86smul_flag GR16:$src1, imm:$src2))]>, OpSize;
1152 def IMUL32rri : Ii32<0x69, MRMSrcReg, // GR32 = GR32*I32
1153 (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
1154 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1155 [(set GR32:$dst, EFLAGS,
1156 (X86smul_flag GR32:$src1, imm:$src2))]>;
1157 def IMUL16rri8 : Ii8<0x6B, MRMSrcReg, // GR16 = GR16*I8
1158 (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
1159 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1160 [(set GR16:$dst, EFLAGS,
1161 (X86smul_flag GR16:$src1, i16immSExt8:$src2))]>,
1163 def IMUL32rri8 : Ii8<0x6B, MRMSrcReg, // GR32 = GR32*I8
1164 (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
1165 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1166 [(set GR32:$dst, EFLAGS,
1167 (X86smul_flag GR32:$src1, i32immSExt8:$src2))]>;
1169 // Memory-Integer Signed Integer Multiply
1170 def IMUL16rmi : Ii16<0x69, MRMSrcMem, // GR16 = [mem16]*I16
1171 (outs GR16:$dst), (ins i16mem:$src1, i16imm:$src2),
1172 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1173 [(set GR16:$dst, EFLAGS,
1174 (X86smul_flag (load addr:$src1), imm:$src2))]>,
1176 def IMUL32rmi : Ii32<0x69, MRMSrcMem, // GR32 = [mem32]*I32
1177 (outs GR32:$dst), (ins i32mem:$src1, i32imm:$src2),
1178 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1179 [(set GR32:$dst, EFLAGS,
1180 (X86smul_flag (load addr:$src1), imm:$src2))]>;
1181 def IMUL16rmi8 : Ii8<0x6B, MRMSrcMem, // GR16 = [mem16]*I8
1182 (outs GR16:$dst), (ins i16mem:$src1, i16i8imm :$src2),
1183 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1184 [(set GR16:$dst, EFLAGS,
1185 (X86smul_flag (load addr:$src1),
1186 i16immSExt8:$src2))]>, OpSize;
1187 def IMUL32rmi8 : Ii8<0x6B, MRMSrcMem, // GR32 = [mem32]*I8
1188 (outs GR32:$dst), (ins i32mem:$src1, i32i8imm: $src2),
1189 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1190 [(set GR32:$dst, EFLAGS,
1191 (X86smul_flag (load addr:$src1),
1192 i32immSExt8:$src2))]>;
1193 } // Defs = [EFLAGS]
1195 //===----------------------------------------------------------------------===//
1196 // Test instructions are just like AND, except they don't generate a result.
1198 let Defs = [EFLAGS] in {
1199 let isCommutable = 1 in { // TEST X, Y --> TEST Y, X
1200 def TEST8rr : I<0x84, MRMSrcReg, (outs), (ins GR8:$src1, GR8:$src2),
1201 "test{b}\t{$src2, $src1|$src1, $src2}",
1202 [(set EFLAGS, (X86cmp (and_su GR8:$src1, GR8:$src2), 0))]>;
1203 def TEST16rr : I<0x85, MRMSrcReg, (outs), (ins GR16:$src1, GR16:$src2),
1204 "test{w}\t{$src2, $src1|$src1, $src2}",
1205 [(set EFLAGS, (X86cmp (and_su GR16:$src1, GR16:$src2),
1208 def TEST32rr : I<0x85, MRMSrcReg, (outs), (ins GR32:$src1, GR32:$src2),
1209 "test{l}\t{$src2, $src1|$src1, $src2}",
1210 [(set EFLAGS, (X86cmp (and_su GR32:$src1, GR32:$src2),
1214 def TEST8i8 : Ii8<0xA8, RawFrm, (outs), (ins i8imm:$src),
1215 "test{b}\t{$src, %al|%al, $src}", []>;
1216 def TEST16i16 : Ii16<0xA9, RawFrm, (outs), (ins i16imm:$src),
1217 "test{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1218 def TEST32i32 : Ii32<0xA9, RawFrm, (outs), (ins i32imm:$src),
1219 "test{l}\t{$src, %eax|%eax, $src}", []>;
1221 def TEST8rm : I<0x84, MRMSrcMem, (outs), (ins GR8 :$src1, i8mem :$src2),
1222 "test{b}\t{$src2, $src1|$src1, $src2}",
1223 [(set EFLAGS, (X86cmp (and GR8:$src1, (loadi8 addr:$src2)),
1225 def TEST16rm : I<0x85, MRMSrcMem, (outs), (ins GR16:$src1, i16mem:$src2),
1226 "test{w}\t{$src2, $src1|$src1, $src2}",
1227 [(set EFLAGS, (X86cmp (and GR16:$src1,
1228 (loadi16 addr:$src2)), 0))]>, OpSize;
1229 def TEST32rm : I<0x85, MRMSrcMem, (outs), (ins GR32:$src1, i32mem:$src2),
1230 "test{l}\t{$src2, $src1|$src1, $src2}",
1231 [(set EFLAGS, (X86cmp (and GR32:$src1,
1232 (loadi32 addr:$src2)), 0))]>;
1234 def TEST8ri : Ii8 <0xF6, MRM0r, // flags = GR8 & imm8
1235 (outs), (ins GR8:$src1, i8imm:$src2),
1236 "test{b}\t{$src2, $src1|$src1, $src2}",
1237 [(set EFLAGS, (X86cmp (and_su GR8:$src1, imm:$src2), 0))]>;
1238 def TEST16ri : Ii16<0xF7, MRM0r, // flags = GR16 & imm16
1239 (outs), (ins GR16:$src1, i16imm:$src2),
1240 "test{w}\t{$src2, $src1|$src1, $src2}",
1241 [(set EFLAGS, (X86cmp (and_su GR16:$src1, imm:$src2), 0))]>,
1243 def TEST32ri : Ii32<0xF7, MRM0r, // flags = GR32 & imm32
1244 (outs), (ins GR32:$src1, i32imm:$src2),
1245 "test{l}\t{$src2, $src1|$src1, $src2}",
1246 [(set EFLAGS, (X86cmp (and_su GR32:$src1, imm:$src2), 0))]>;
1248 def TEST8mi : Ii8 <0xF6, MRM0m, // flags = [mem8] & imm8
1249 (outs), (ins i8mem:$src1, i8imm:$src2),
1250 "test{b}\t{$src2, $src1|$src1, $src2}",
1251 [(set EFLAGS, (X86cmp (and (loadi8 addr:$src1), imm:$src2),
1253 def TEST16mi : Ii16<0xF7, MRM0m, // flags = [mem16] & imm16
1254 (outs), (ins i16mem:$src1, i16imm:$src2),
1255 "test{w}\t{$src2, $src1|$src1, $src2}",
1256 [(set EFLAGS, (X86cmp (and (loadi16 addr:$src1), imm:$src2),
1258 def TEST32mi : Ii32<0xF7, MRM0m, // flags = [mem32] & imm32
1259 (outs), (ins i32mem:$src1, i32imm:$src2),
1260 "test{l}\t{$src2, $src1|$src1, $src2}",
1261 [(set EFLAGS, (X86cmp (and (loadi32 addr:$src1), imm:$src2),
1263 } // Defs = [EFLAGS]