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 def ADD64rr : RI<0x01, MRMDestReg, (outs GR64:$dst),
691 (ins GR64:$src1, GR64:$src2),
692 "add{q}\t{$src2, $dst|$dst, $src2}",
693 [(set GR64:$dst, EFLAGS,
694 (X86add_flag GR64:$src1, GR64:$src2))]>;
695 } // end isConvertibleToThreeAddress
696 } // end isCommutable
698 // These are alternate spellings for use by the disassembler, we mark them as
699 // code gen only to ensure they aren't matched by the assembler.
700 let isCodeGenOnly = 1 in {
701 def ADD8rr_alt: I<0x02, MRMSrcReg,
702 (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
703 "add{b}\t{$src2, $dst|$dst, $src2}", []>;
704 def ADD16rr_alt: I<0x03, MRMSrcReg,
705 (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
706 "add{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
707 def ADD32rr_alt: I<0x03, MRMSrcReg,
708 (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
709 "add{l}\t{$src2, $dst|$dst, $src2}", []>;
710 def ADD64rr_alt : RI<0x03, MRMSrcReg,
711 (outs GR64:$dst), (ins GR64:$src1, GR64:$src2),
712 "add{l}\t{$src2, $dst|$dst, $src2}", []>;
715 // Register-Memory Addition
716 def ADD8rm : I<0x02, MRMSrcMem, (outs GR8 :$dst),
717 (ins GR8 :$src1, i8mem :$src2),
718 "add{b}\t{$src2, $dst|$dst, $src2}",
719 [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1,
720 (load addr:$src2)))]>;
721 def ADD16rm : I<0x03, MRMSrcMem, (outs GR16:$dst),
722 (ins GR16:$src1, i16mem:$src2),
723 "add{w}\t{$src2, $dst|$dst, $src2}",
724 [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
725 (load addr:$src2)))]>, OpSize;
726 def ADD32rm : I<0x03, MRMSrcMem, (outs GR32:$dst),
727 (ins GR32:$src1, i32mem:$src2),
728 "add{l}\t{$src2, $dst|$dst, $src2}",
729 [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
730 (load addr:$src2)))]>;
731 def ADD64rm : RI<0x03, MRMSrcMem, (outs GR64:$dst),
732 (ins GR64:$src1, i64mem:$src2),
733 "add{q}\t{$src2, $dst|$dst, $src2}",
734 [(set GR64:$dst, EFLAGS,
735 (X86add_flag GR64:$src1, (load addr:$src2)))]>;
737 // Register-Integer Addition
738 def ADD8ri : Ii8<0x80, MRM0r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
739 "add{b}\t{$src2, $dst|$dst, $src2}",
740 [(set GR8:$dst, EFLAGS,
741 (X86add_flag GR8:$src1, imm:$src2))]>;
743 let isConvertibleToThreeAddress = 1 in { // Can transform into LEA.
744 // Register-Integer Addition
745 def ADD16ri : Ii16<0x81, MRM0r, (outs GR16:$dst),
746 (ins GR16:$src1, i16imm:$src2),
747 "add{w}\t{$src2, $dst|$dst, $src2}",
748 [(set GR16:$dst, EFLAGS,
749 (X86add_flag GR16:$src1, imm:$src2))]>, OpSize;
750 def ADD32ri : Ii32<0x81, MRM0r, (outs GR32:$dst),
751 (ins GR32:$src1, i32imm:$src2),
752 "add{l}\t{$src2, $dst|$dst, $src2}",
753 [(set GR32:$dst, EFLAGS,
754 (X86add_flag GR32:$src1, imm:$src2))]>;
755 def ADD16ri8 : Ii8<0x83, MRM0r, (outs GR16:$dst),
756 (ins GR16:$src1, i16i8imm:$src2),
757 "add{w}\t{$src2, $dst|$dst, $src2}",
758 [(set GR16:$dst, EFLAGS,
759 (X86add_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
760 def ADD32ri8 : Ii8<0x83, MRM0r, (outs GR32:$dst),
761 (ins GR32:$src1, i32i8imm:$src2),
762 "add{l}\t{$src2, $dst|$dst, $src2}",
763 [(set GR32:$dst, EFLAGS,
764 (X86add_flag GR32:$src1, i32immSExt8:$src2))]>;
765 def ADD64ri8 : RIi8<0x83, MRM0r, (outs GR64:$dst),
766 (ins GR64:$src1, i64i8imm:$src2),
767 "add{q}\t{$src2, $dst|$dst, $src2}",
768 [(set GR64:$dst, EFLAGS,
769 (X86add_flag GR64:$src1, i64immSExt8:$src2))]>;
770 def ADD64ri32 : RIi32<0x81, MRM0r, (outs GR64:$dst),
771 (ins GR64:$src1, i64i32imm:$src2),
772 "add{q}\t{$src2, $dst|$dst, $src2}",
773 [(set GR64:$dst, EFLAGS,
774 (X86add_flag GR64:$src1, i64immSExt32:$src2))]>;
776 } // Constraints = "$src1 = $dst"
778 // Memory-Register Addition
779 def ADD8mr : I<0x00, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
780 "add{b}\t{$src2, $dst|$dst, $src2}",
781 [(store (add (load addr:$dst), GR8:$src2), addr:$dst),
783 def ADD16mr : I<0x01, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
784 "add{w}\t{$src2, $dst|$dst, $src2}",
785 [(store (add (load addr:$dst), GR16:$src2), addr:$dst),
786 (implicit EFLAGS)]>, OpSize;
787 def ADD32mr : I<0x01, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
788 "add{l}\t{$src2, $dst|$dst, $src2}",
789 [(store (add (load addr:$dst), GR32:$src2), addr:$dst),
791 def ADD64mr : RI<0x01, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
792 "add{q}\t{$src2, $dst|$dst, $src2}",
793 [(store (add (load addr:$dst), GR64:$src2), addr:$dst),
795 def ADD8mi : Ii8<0x80, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src2),
796 "add{b}\t{$src2, $dst|$dst, $src2}",
797 [(store (add (loadi8 addr:$dst), imm:$src2), addr:$dst),
799 def ADD16mi : Ii16<0x81, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src2),
800 "add{w}\t{$src2, $dst|$dst, $src2}",
801 [(store (add (loadi16 addr:$dst), imm:$src2), addr:$dst),
802 (implicit EFLAGS)]>, OpSize;
803 def ADD32mi : Ii32<0x81, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src2),
804 "add{l}\t{$src2, $dst|$dst, $src2}",
805 [(store (add (loadi32 addr:$dst), imm:$src2), addr:$dst),
807 def ADD64mi32 : RIi32<0x81, MRM0m, (outs), (ins i64mem:$dst, i64i32imm :$src2),
808 "add{q}\t{$src2, $dst|$dst, $src2}",
809 [(store (add (load addr:$dst), i64immSExt32:$src2), addr:$dst),
811 def ADD16mi8 : Ii8<0x83, MRM0m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
812 "add{w}\t{$src2, $dst|$dst, $src2}",
813 [(store (add (load addr:$dst), i16immSExt8:$src2),
815 (implicit EFLAGS)]>, OpSize;
816 def ADD32mi8 : Ii8<0x83, MRM0m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
817 "add{l}\t{$src2, $dst|$dst, $src2}",
818 [(store (add (load addr:$dst), i32immSExt8:$src2),
821 def ADD64mi8 : RIi8<0x83, MRM0m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
822 "add{q}\t{$src2, $dst|$dst, $src2}",
823 [(store (add (load addr:$dst), i64immSExt8:$src2), addr:$dst),
827 def ADD8i8 : Ii8<0x04, RawFrm, (outs), (ins i8imm:$src),
828 "add{b}\t{$src, %al|%al, $src}", []>;
829 def ADD16i16 : Ii16<0x05, RawFrm, (outs), (ins i16imm:$src),
830 "add{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
831 def ADD32i32 : Ii32<0x05, RawFrm, (outs), (ins i32imm:$src),
832 "add{l}\t{$src, %eax|%eax, $src}", []>;
833 def ADD64i32 : RIi32<0x05, RawFrm, (outs), (ins i64i32imm:$src),
834 "add{q}\t{$src, %rax|%rax, $src}", []>;
836 let Uses = [EFLAGS] in {
837 let Constraints = "$src1 = $dst" in {
838 let isCommutable = 1 in { // X = ADC Y, Z --> X = ADC Z, Y
839 def ADC8rr : I<0x10, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
840 "adc{b}\t{$src2, $dst|$dst, $src2}",
841 [(set GR8:$dst, (adde GR8:$src1, GR8:$src2))]>;
842 def ADC16rr : I<0x11, MRMDestReg, (outs GR16:$dst),
843 (ins GR16:$src1, GR16:$src2),
844 "adc{w}\t{$src2, $dst|$dst, $src2}",
845 [(set GR16:$dst, (adde GR16:$src1, GR16:$src2))]>, OpSize;
846 def ADC32rr : I<0x11, MRMDestReg, (outs GR32:$dst),
847 (ins GR32:$src1, GR32:$src2),
848 "adc{l}\t{$src2, $dst|$dst, $src2}",
849 [(set GR32:$dst, (adde GR32:$src1, GR32:$src2))]>;
850 def ADC64rr : RI<0x11, MRMDestReg, (outs GR64:$dst),
851 (ins GR64:$src1, GR64:$src2),
852 "adc{q}\t{$src2, $dst|$dst, $src2}",
853 [(set GR64:$dst, (adde GR64:$src1, GR64:$src2))]>;
856 let isCodeGenOnly = 1 in {
857 def ADC8rr_REV : I<0x12, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
858 "adc{b}\t{$src2, $dst|$dst, $src2}", []>;
859 def ADC16rr_REV : I<0x13, MRMSrcReg, (outs GR16:$dst),
860 (ins GR16:$src1, GR16:$src2),
861 "adc{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
862 def ADC32rr_REV : I<0x13, MRMSrcReg, (outs GR32:$dst),
863 (ins GR32:$src1, GR32:$src2),
864 "adc{l}\t{$src2, $dst|$dst, $src2}", []>;
865 def ADC64rr_REV : RI<0x13, MRMSrcReg , (outs GR32:$dst),
866 (ins GR64:$src1, GR64:$src2),
867 "adc{q}\t{$src2, $dst|$dst, $src2}", []>;
870 def ADC8rm : I<0x12, MRMSrcMem ,
871 (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
872 "adc{b}\t{$src2, $dst|$dst, $src2}",
873 [(set GR8:$dst, (adde GR8:$src1, (load addr:$src2)))]>;
874 def ADC16rm : I<0x13, MRMSrcMem , (outs GR16:$dst),
875 (ins GR16:$src1, i16mem:$src2),
876 "adc{w}\t{$src2, $dst|$dst, $src2}",
877 [(set GR16:$dst, (adde GR16:$src1, (load addr:$src2)))]>,
879 def ADC32rm : I<0x13, MRMSrcMem ,
880 (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
881 "adc{l}\t{$src2, $dst|$dst, $src2}",
882 [(set GR32:$dst, (adde GR32:$src1, (load addr:$src2)))]>;
883 def ADC64rm : RI<0x13, MRMSrcMem , (outs GR64:$dst),
884 (ins GR64:$src1, i64mem:$src2),
885 "adc{q}\t{$src2, $dst|$dst, $src2}",
886 [(set GR64:$dst, (adde GR64:$src1, (load addr:$src2)))]>;
887 def ADC8ri : Ii8<0x80, MRM2r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
888 "adc{b}\t{$src2, $dst|$dst, $src2}",
889 [(set GR8:$dst, (adde GR8:$src1, imm:$src2))]>;
890 def ADC16ri : Ii16<0x81, MRM2r,
891 (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
892 "adc{w}\t{$src2, $dst|$dst, $src2}",
893 [(set GR16:$dst, (adde GR16:$src1, imm:$src2))]>, OpSize;
894 def ADC16ri8 : Ii8<0x83, MRM2r, (outs GR16:$dst),
895 (ins GR16:$src1, i16i8imm:$src2),
896 "adc{w}\t{$src2, $dst|$dst, $src2}",
897 [(set GR16:$dst, (adde GR16:$src1, i16immSExt8:$src2))]>,
899 def ADC32ri : Ii32<0x81, MRM2r, (outs GR32:$dst),
900 (ins GR32:$src1, i32imm:$src2),
901 "adc{l}\t{$src2, $dst|$dst, $src2}",
902 [(set GR32:$dst, (adde GR32:$src1, imm:$src2))]>;
903 def ADC32ri8 : Ii8<0x83, MRM2r, (outs GR32:$dst),
904 (ins GR32:$src1, i32i8imm:$src2),
905 "adc{l}\t{$src2, $dst|$dst, $src2}",
906 [(set GR32:$dst, (adde GR32:$src1, i32immSExt8:$src2))]>;
907 def ADC64ri32 : RIi32<0x81, MRM2r, (outs GR64:$dst),
908 (ins GR64:$src1, i64i32imm:$src2),
909 "adc{q}\t{$src2, $dst|$dst, $src2}",
910 [(set GR64:$dst, (adde GR64:$src1, i64immSExt32:$src2))]>;
911 def ADC64ri8 : RIi8<0x83, MRM2r, (outs GR64:$dst),
912 (ins GR64:$src1, i64i8imm:$src2),
913 "adc{q}\t{$src2, $dst|$dst, $src2}",
914 [(set GR64:$dst, (adde GR64:$src1, i64immSExt8:$src2))]>;
915 } // Constraints = "$src1 = $dst"
917 def ADC8mr : I<0x10, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
918 "adc{b}\t{$src2, $dst|$dst, $src2}",
919 [(store (adde (load addr:$dst), GR8:$src2), addr:$dst)]>;
920 def ADC16mr : I<0x11, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
921 "adc{w}\t{$src2, $dst|$dst, $src2}",
922 [(store (adde (load addr:$dst), GR16:$src2), addr:$dst)]>,
924 def ADC32mr : I<0x11, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
925 "adc{l}\t{$src2, $dst|$dst, $src2}",
926 [(store (adde (load addr:$dst), GR32:$src2), addr:$dst)]>;
927 def ADC64mr : RI<0x11, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
928 "adc{q}\t{$src2, $dst|$dst, $src2}",
929 [(store (adde (load addr:$dst), GR64:$src2), addr:$dst)]>;
930 def ADC8mi : Ii8<0x80, MRM2m, (outs), (ins i8mem:$dst, i8imm:$src2),
931 "adc{b}\t{$src2, $dst|$dst, $src2}",
932 [(store (adde (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
933 def ADC16mi : Ii16<0x81, MRM2m, (outs), (ins i16mem:$dst, i16imm:$src2),
934 "adc{w}\t{$src2, $dst|$dst, $src2}",
935 [(store (adde (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
937 def ADC16mi8 : Ii8<0x83, MRM2m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
938 "adc{w}\t{$src2, $dst|$dst, $src2}",
939 [(store (adde (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
941 def ADC32mi : Ii32<0x81, MRM2m, (outs), (ins i32mem:$dst, i32imm:$src2),
942 "adc{l}\t{$src2, $dst|$dst, $src2}",
943 [(store (adde (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
944 def ADC32mi8 : Ii8<0x83, MRM2m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
945 "adc{l}\t{$src2, $dst|$dst, $src2}",
946 [(store (adde (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
948 def ADC64mi32 : RIi32<0x81, MRM2m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
949 "adc{q}\t{$src2, $dst|$dst, $src2}",
950 [(store (adde (load addr:$dst), i64immSExt32:$src2),
952 def ADC64mi8 : RIi8<0x83, MRM2m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
953 "adc{q}\t{$src2, $dst|$dst, $src2}",
954 [(store (adde (load addr:$dst), i64immSExt8:$src2),
957 def ADC8i8 : Ii8<0x14, RawFrm, (outs), (ins i8imm:$src),
958 "adc{b}\t{$src, %al|%al, $src}", []>;
959 def ADC16i16 : Ii16<0x15, RawFrm, (outs), (ins i16imm:$src),
960 "adc{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
961 def ADC32i32 : Ii32<0x15, RawFrm, (outs), (ins i32imm:$src),
962 "adc{l}\t{$src, %eax|%eax, $src}", []>;
963 def ADC64i32 : RIi32<0x15, RawFrm, (outs), (ins i64i32imm:$src),
964 "adc{q}\t{$src, %rax|%rax, $src}", []>;
967 let Constraints = "$src1 = $dst" in {
969 // Register-Register Subtraction
970 def SUB8rr : I<0x28, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
971 "sub{b}\t{$src2, $dst|$dst, $src2}",
972 [(set GR8:$dst, EFLAGS,
973 (X86sub_flag GR8:$src1, GR8:$src2))]>;
974 def SUB16rr : I<0x29, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
975 "sub{w}\t{$src2, $dst|$dst, $src2}",
976 [(set GR16:$dst, EFLAGS,
977 (X86sub_flag GR16:$src1, GR16:$src2))]>, OpSize;
978 def SUB32rr : I<0x29, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
979 "sub{l}\t{$src2, $dst|$dst, $src2}",
980 [(set GR32:$dst, EFLAGS,
981 (X86sub_flag GR32:$src1, GR32:$src2))]>;
983 let isCodeGenOnly = 1 in {
984 def SUB8rr_REV : I<0x2A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
985 "sub{b}\t{$src2, $dst|$dst, $src2}", []>;
986 def SUB16rr_REV : I<0x2B, MRMSrcReg, (outs GR16:$dst),
987 (ins GR16:$src1, GR16:$src2),
988 "sub{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
989 def SUB32rr_REV : I<0x2B, MRMSrcReg, (outs GR32:$dst),
990 (ins GR32:$src1, GR32:$src2),
991 "sub{l}\t{$src2, $dst|$dst, $src2}", []>;
994 // Register-Memory Subtraction
995 def SUB8rm : I<0x2A, MRMSrcMem, (outs GR8 :$dst),
996 (ins GR8 :$src1, i8mem :$src2),
997 "sub{b}\t{$src2, $dst|$dst, $src2}",
998 [(set GR8:$dst, EFLAGS,
999 (X86sub_flag GR8:$src1, (load addr:$src2)))]>;
1000 def SUB16rm : I<0x2B, MRMSrcMem, (outs GR16:$dst),
1001 (ins GR16:$src1, i16mem:$src2),
1002 "sub{w}\t{$src2, $dst|$dst, $src2}",
1003 [(set GR16:$dst, EFLAGS,
1004 (X86sub_flag GR16:$src1, (load addr:$src2)))]>, OpSize;
1005 def SUB32rm : I<0x2B, MRMSrcMem, (outs GR32:$dst),
1006 (ins GR32:$src1, i32mem:$src2),
1007 "sub{l}\t{$src2, $dst|$dst, $src2}",
1008 [(set GR32:$dst, EFLAGS,
1009 (X86sub_flag GR32:$src1, (load addr:$src2)))]>;
1011 // Register-Integer Subtraction
1012 def SUB8ri : Ii8 <0x80, MRM5r, (outs GR8:$dst),
1013 (ins GR8:$src1, i8imm:$src2),
1014 "sub{b}\t{$src2, $dst|$dst, $src2}",
1015 [(set GR8:$dst, EFLAGS,
1016 (X86sub_flag GR8:$src1, imm:$src2))]>;
1017 def SUB16ri : Ii16<0x81, MRM5r, (outs GR16:$dst),
1018 (ins GR16:$src1, i16imm:$src2),
1019 "sub{w}\t{$src2, $dst|$dst, $src2}",
1020 [(set GR16:$dst, EFLAGS,
1021 (X86sub_flag GR16:$src1, imm:$src2))]>, OpSize;
1022 def SUB32ri : Ii32<0x81, MRM5r, (outs GR32:$dst),
1023 (ins GR32:$src1, i32imm:$src2),
1024 "sub{l}\t{$src2, $dst|$dst, $src2}",
1025 [(set GR32:$dst, EFLAGS,
1026 (X86sub_flag GR32:$src1, imm:$src2))]>;
1027 def SUB16ri8 : Ii8<0x83, MRM5r, (outs GR16:$dst),
1028 (ins GR16:$src1, i16i8imm:$src2),
1029 "sub{w}\t{$src2, $dst|$dst, $src2}",
1030 [(set GR16:$dst, EFLAGS,
1031 (X86sub_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
1032 def SUB32ri8 : Ii8<0x83, MRM5r, (outs GR32:$dst),
1033 (ins GR32:$src1, i32i8imm:$src2),
1034 "sub{l}\t{$src2, $dst|$dst, $src2}",
1035 [(set GR32:$dst, EFLAGS,
1036 (X86sub_flag GR32:$src1, i32immSExt8:$src2))]>;
1037 } // Constraints = "$src1 = $dst"
1039 // Memory-Register Subtraction
1040 def SUB8mr : I<0x28, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src2),
1041 "sub{b}\t{$src2, $dst|$dst, $src2}",
1042 [(store (sub (load addr:$dst), GR8:$src2), addr:$dst),
1043 (implicit EFLAGS)]>;
1044 def SUB16mr : I<0x29, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1045 "sub{w}\t{$src2, $dst|$dst, $src2}",
1046 [(store (sub (load addr:$dst), GR16:$src2), addr:$dst),
1047 (implicit EFLAGS)]>, OpSize;
1048 def SUB32mr : I<0x29, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1049 "sub{l}\t{$src2, $dst|$dst, $src2}",
1050 [(store (sub (load addr:$dst), GR32:$src2), addr:$dst),
1051 (implicit EFLAGS)]>;
1053 // Memory-Integer Subtraction
1054 def SUB8mi : Ii8<0x80, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src2),
1055 "sub{b}\t{$src2, $dst|$dst, $src2}",
1056 [(store (sub (loadi8 addr:$dst), imm:$src2), addr:$dst),
1057 (implicit EFLAGS)]>;
1058 def SUB16mi : Ii16<0x81, MRM5m, (outs), (ins i16mem:$dst, i16imm:$src2),
1059 "sub{w}\t{$src2, $dst|$dst, $src2}",
1060 [(store (sub (loadi16 addr:$dst), imm:$src2),addr:$dst),
1061 (implicit EFLAGS)]>, OpSize;
1062 def SUB32mi : Ii32<0x81, MRM5m, (outs), (ins i32mem:$dst, i32imm:$src2),
1063 "sub{l}\t{$src2, $dst|$dst, $src2}",
1064 [(store (sub (loadi32 addr:$dst), imm:$src2),addr:$dst),
1065 (implicit EFLAGS)]>;
1066 def SUB16mi8 : Ii8<0x83, MRM5m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1067 "sub{w}\t{$src2, $dst|$dst, $src2}",
1068 [(store (sub (load addr:$dst), i16immSExt8:$src2),
1070 (implicit EFLAGS)]>, OpSize;
1071 def SUB32mi8 : Ii8<0x83, MRM5m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1072 "sub{l}\t{$src2, $dst|$dst, $src2}",
1073 [(store (sub (load addr:$dst), i32immSExt8:$src2),
1075 (implicit EFLAGS)]>;
1077 def SUB8i8 : Ii8<0x2C, RawFrm, (outs), (ins i8imm:$src),
1078 "sub{b}\t{$src, %al|%al, $src}", []>;
1079 def SUB16i16 : Ii16<0x2D, RawFrm, (outs), (ins i16imm:$src),
1080 "sub{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1081 def SUB32i32 : Ii32<0x2D, RawFrm, (outs), (ins i32imm:$src),
1082 "sub{l}\t{$src, %eax|%eax, $src}", []>;
1084 let Uses = [EFLAGS] in {
1085 let Constraints = "$src1 = $dst" in {
1086 def SBB8rr : I<0x18, MRMDestReg, (outs GR8:$dst),
1087 (ins GR8:$src1, GR8:$src2),
1088 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1089 [(set GR8:$dst, (sube GR8:$src1, GR8:$src2))]>;
1090 def SBB16rr : I<0x19, MRMDestReg, (outs GR16:$dst),
1091 (ins GR16:$src1, GR16:$src2),
1092 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1093 [(set GR16:$dst, (sube GR16:$src1, GR16:$src2))]>, OpSize;
1094 def SBB32rr : I<0x19, MRMDestReg, (outs GR32:$dst),
1095 (ins GR32:$src1, GR32:$src2),
1096 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1097 [(set GR32:$dst, (sube GR32:$src1, GR32:$src2))]>;
1098 } // Constraints = "$src1 = $dst"
1101 def SBB8mr : I<0x18, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1102 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1103 [(store (sube (load addr:$dst), GR8:$src2), addr:$dst)]>;
1104 def SBB16mr : I<0x19, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1105 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1106 [(store (sube (load addr:$dst), GR16:$src2), addr:$dst)]>,
1108 def SBB32mr : I<0x19, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1109 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1110 [(store (sube (load addr:$dst), GR32:$src2), addr:$dst)]>;
1111 def SBB8mi : Ii8<0x80, MRM3m, (outs), (ins i8mem:$dst, i8imm:$src2),
1112 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1113 [(store (sube (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1114 def SBB16mi : Ii16<0x81, MRM3m, (outs), (ins i16mem:$dst, i16imm:$src2),
1115 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1116 [(store (sube (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1118 def SBB16mi8 : Ii8<0x83, MRM3m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1119 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1120 [(store (sube (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1122 def SBB32mi : Ii32<0x81, MRM3m, (outs), (ins i32mem:$dst, i32imm:$src2),
1123 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1124 [(store (sube (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1125 def SBB32mi8 : Ii8<0x83, MRM3m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1126 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1127 [(store (sube (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1129 def SBB8i8 : Ii8<0x1C, RawFrm, (outs), (ins i8imm:$src),
1130 "sbb{b}\t{$src, %al|%al, $src}", []>;
1131 def SBB16i16 : Ii16<0x1D, RawFrm, (outs), (ins i16imm:$src),
1132 "sbb{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1133 def SBB32i32 : Ii32<0x1D, RawFrm, (outs), (ins i32imm:$src),
1134 "sbb{l}\t{$src, %eax|%eax, $src}", []>;
1136 let Constraints = "$src1 = $dst" in {
1138 let isCodeGenOnly = 1 in {
1139 def SBB8rr_REV : I<0x1A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1140 "sbb{b}\t{$src2, $dst|$dst, $src2}", []>;
1141 def SBB16rr_REV : I<0x1B, MRMSrcReg, (outs GR16:$dst),
1142 (ins GR16:$src1, GR16:$src2),
1143 "sbb{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1144 def SBB32rr_REV : I<0x1B, MRMSrcReg, (outs GR32:$dst),
1145 (ins GR32:$src1, GR32:$src2),
1146 "sbb{l}\t{$src2, $dst|$dst, $src2}", []>;
1149 def SBB8rm : I<0x1A, MRMSrcMem, (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1150 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1151 [(set GR8:$dst, (sube GR8:$src1, (load addr:$src2)))]>;
1152 def SBB16rm : I<0x1B, MRMSrcMem, (outs GR16:$dst),
1153 (ins GR16:$src1, i16mem:$src2),
1154 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1155 [(set GR16:$dst, (sube GR16:$src1, (load addr:$src2)))]>,
1157 def SBB32rm : I<0x1B, MRMSrcMem, (outs GR32:$dst),
1158 (ins GR32:$src1, i32mem:$src2),
1159 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1160 [(set GR32:$dst, (sube GR32:$src1, (load addr:$src2)))]>;
1161 def SBB8ri : Ii8<0x80, MRM3r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1162 "sbb{b}\t{$src2, $dst|$dst, $src2}",
1163 [(set GR8:$dst, (sube GR8:$src1, imm:$src2))]>;
1164 def SBB16ri : Ii16<0x81, MRM3r, (outs GR16:$dst),
1165 (ins GR16:$src1, i16imm:$src2),
1166 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1167 [(set GR16:$dst, (sube GR16:$src1, imm:$src2))]>, OpSize;
1168 def SBB16ri8 : Ii8<0x83, MRM3r, (outs GR16:$dst),
1169 (ins GR16:$src1, i16i8imm:$src2),
1170 "sbb{w}\t{$src2, $dst|$dst, $src2}",
1171 [(set GR16:$dst, (sube GR16:$src1, i16immSExt8:$src2))]>,
1173 def SBB32ri : Ii32<0x81, MRM3r, (outs GR32:$dst),
1174 (ins GR32:$src1, i32imm:$src2),
1175 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1176 [(set GR32:$dst, (sube GR32:$src1, imm:$src2))]>;
1177 def SBB32ri8 : Ii8<0x83, MRM3r, (outs GR32:$dst),
1178 (ins GR32:$src1, i32i8imm:$src2),
1179 "sbb{l}\t{$src2, $dst|$dst, $src2}",
1180 [(set GR32:$dst, (sube GR32:$src1, i32immSExt8:$src2))]>;
1181 } // Constraints = "$src1 = $dst"
1183 } // Uses = [EFLAGS]
1184 } // Defs = [EFLAGS]
1186 let Defs = [EFLAGS] in {
1187 let Constraints = "$src1 = $dst" in {
1189 let isCommutable = 1 in { // X = IMUL Y, Z --> X = IMUL Z, Y
1190 // Register-Register Signed Integer Multiply
1191 def IMUL16rr : I<0xAF, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
1192 "imul{w}\t{$src2, $dst|$dst, $src2}",
1193 [(set GR16:$dst, EFLAGS,
1194 (X86smul_flag GR16:$src1, GR16:$src2))]>, TB, OpSize;
1195 def IMUL32rr : I<0xAF, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
1196 "imul{l}\t{$src2, $dst|$dst, $src2}",
1197 [(set GR32:$dst, EFLAGS,
1198 (X86smul_flag GR32:$src1, GR32:$src2))]>, TB;
1201 // Register-Memory Signed Integer Multiply
1202 def IMUL16rm : I<0xAF, MRMSrcMem, (outs GR16:$dst),
1203 (ins GR16:$src1, i16mem:$src2),
1204 "imul{w}\t{$src2, $dst|$dst, $src2}",
1205 [(set GR16:$dst, EFLAGS,
1206 (X86smul_flag GR16:$src1, (load addr:$src2)))]>,
1208 def IMUL32rm : I<0xAF, MRMSrcMem, (outs GR32:$dst),
1209 (ins GR32:$src1, i32mem:$src2),
1210 "imul{l}\t{$src2, $dst|$dst, $src2}",
1211 [(set GR32:$dst, EFLAGS,
1212 (X86smul_flag GR32:$src1, (load addr:$src2)))]>, TB;
1213 } // Constraints = "$src1 = $dst"
1215 } // Defs = [EFLAGS]
1217 // Suprisingly enough, these are not two address instructions!
1218 let Defs = [EFLAGS] in {
1219 // Register-Integer Signed Integer Multiply
1220 def IMUL16rri : Ii16<0x69, MRMSrcReg, // GR16 = GR16*I16
1221 (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
1222 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1223 [(set GR16:$dst, EFLAGS,
1224 (X86smul_flag GR16:$src1, imm:$src2))]>, OpSize;
1225 def IMUL32rri : Ii32<0x69, MRMSrcReg, // GR32 = GR32*I32
1226 (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
1227 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1228 [(set GR32:$dst, EFLAGS,
1229 (X86smul_flag GR32:$src1, imm:$src2))]>;
1230 def IMUL16rri8 : Ii8<0x6B, MRMSrcReg, // GR16 = GR16*I8
1231 (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
1232 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1233 [(set GR16:$dst, EFLAGS,
1234 (X86smul_flag GR16:$src1, i16immSExt8:$src2))]>,
1236 def IMUL32rri8 : Ii8<0x6B, MRMSrcReg, // GR32 = GR32*I8
1237 (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
1238 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1239 [(set GR32:$dst, EFLAGS,
1240 (X86smul_flag GR32:$src1, i32immSExt8:$src2))]>;
1242 // Memory-Integer Signed Integer Multiply
1243 def IMUL16rmi : Ii16<0x69, MRMSrcMem, // GR16 = [mem16]*I16
1244 (outs GR16:$dst), (ins i16mem:$src1, i16imm:$src2),
1245 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1246 [(set GR16:$dst, EFLAGS,
1247 (X86smul_flag (load addr:$src1), imm:$src2))]>,
1249 def IMUL32rmi : Ii32<0x69, MRMSrcMem, // GR32 = [mem32]*I32
1250 (outs GR32:$dst), (ins i32mem:$src1, i32imm:$src2),
1251 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1252 [(set GR32:$dst, EFLAGS,
1253 (X86smul_flag (load addr:$src1), imm:$src2))]>;
1254 def IMUL16rmi8 : Ii8<0x6B, MRMSrcMem, // GR16 = [mem16]*I8
1255 (outs GR16:$dst), (ins i16mem:$src1, i16i8imm :$src2),
1256 "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1257 [(set GR16:$dst, EFLAGS,
1258 (X86smul_flag (load addr:$src1),
1259 i16immSExt8:$src2))]>, OpSize;
1260 def IMUL32rmi8 : Ii8<0x6B, MRMSrcMem, // GR32 = [mem32]*I8
1261 (outs GR32:$dst), (ins i32mem:$src1, i32i8imm: $src2),
1262 "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1263 [(set GR32:$dst, EFLAGS,
1264 (X86smul_flag (load addr:$src1),
1265 i32immSExt8:$src2))]>;
1266 } // Defs = [EFLAGS]
1268 //===----------------------------------------------------------------------===//
1269 // Test instructions are just like AND, except they don't generate a result.
1271 let Defs = [EFLAGS] in {
1272 let isCommutable = 1 in { // TEST X, Y --> TEST Y, X
1273 def TEST8rr : I<0x84, MRMSrcReg, (outs), (ins GR8:$src1, GR8:$src2),
1274 "test{b}\t{$src2, $src1|$src1, $src2}",
1275 [(set EFLAGS, (X86cmp (and_su GR8:$src1, GR8:$src2), 0))]>;
1276 def TEST16rr : I<0x85, MRMSrcReg, (outs), (ins GR16:$src1, GR16:$src2),
1277 "test{w}\t{$src2, $src1|$src1, $src2}",
1278 [(set EFLAGS, (X86cmp (and_su GR16:$src1, GR16:$src2),
1281 def TEST32rr : I<0x85, MRMSrcReg, (outs), (ins GR32:$src1, GR32:$src2),
1282 "test{l}\t{$src2, $src1|$src1, $src2}",
1283 [(set EFLAGS, (X86cmp (and_su GR32:$src1, GR32:$src2),
1287 def TEST8i8 : Ii8<0xA8, RawFrm, (outs), (ins i8imm:$src),
1288 "test{b}\t{$src, %al|%al, $src}", []>;
1289 def TEST16i16 : Ii16<0xA9, RawFrm, (outs), (ins i16imm:$src),
1290 "test{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1291 def TEST32i32 : Ii32<0xA9, RawFrm, (outs), (ins i32imm:$src),
1292 "test{l}\t{$src, %eax|%eax, $src}", []>;
1294 def TEST8rm : I<0x84, MRMSrcMem, (outs), (ins GR8 :$src1, i8mem :$src2),
1295 "test{b}\t{$src2, $src1|$src1, $src2}",
1296 [(set EFLAGS, (X86cmp (and GR8:$src1, (loadi8 addr:$src2)),
1298 def TEST16rm : I<0x85, MRMSrcMem, (outs), (ins GR16:$src1, i16mem:$src2),
1299 "test{w}\t{$src2, $src1|$src1, $src2}",
1300 [(set EFLAGS, (X86cmp (and GR16:$src1,
1301 (loadi16 addr:$src2)), 0))]>, OpSize;
1302 def TEST32rm : I<0x85, MRMSrcMem, (outs), (ins GR32:$src1, i32mem:$src2),
1303 "test{l}\t{$src2, $src1|$src1, $src2}",
1304 [(set EFLAGS, (X86cmp (and GR32:$src1,
1305 (loadi32 addr:$src2)), 0))]>;
1307 def TEST8ri : Ii8 <0xF6, MRM0r, // flags = GR8 & imm8
1308 (outs), (ins GR8:$src1, i8imm:$src2),
1309 "test{b}\t{$src2, $src1|$src1, $src2}",
1310 [(set EFLAGS, (X86cmp (and_su GR8:$src1, imm:$src2), 0))]>;
1311 def TEST16ri : Ii16<0xF7, MRM0r, // flags = GR16 & imm16
1312 (outs), (ins GR16:$src1, i16imm:$src2),
1313 "test{w}\t{$src2, $src1|$src1, $src2}",
1314 [(set EFLAGS, (X86cmp (and_su GR16:$src1, imm:$src2), 0))]>,
1316 def TEST32ri : Ii32<0xF7, MRM0r, // flags = GR32 & imm32
1317 (outs), (ins GR32:$src1, i32imm:$src2),
1318 "test{l}\t{$src2, $src1|$src1, $src2}",
1319 [(set EFLAGS, (X86cmp (and_su GR32:$src1, imm:$src2), 0))]>;
1321 def TEST8mi : Ii8 <0xF6, MRM0m, // flags = [mem8] & imm8
1322 (outs), (ins i8mem:$src1, i8imm:$src2),
1323 "test{b}\t{$src2, $src1|$src1, $src2}",
1324 [(set EFLAGS, (X86cmp (and (loadi8 addr:$src1), imm:$src2),
1326 def TEST16mi : Ii16<0xF7, MRM0m, // flags = [mem16] & imm16
1327 (outs), (ins i16mem:$src1, i16imm:$src2),
1328 "test{w}\t{$src2, $src1|$src1, $src2}",
1329 [(set EFLAGS, (X86cmp (and (loadi16 addr:$src1), imm:$src2),
1331 def TEST32mi : Ii32<0xF7, MRM0m, // flags = [mem32] & imm32
1332 (outs), (ins i32mem:$src1, i32imm:$src2),
1333 "test{l}\t{$src2, $src1|$src1, $src2}",
1334 [(set EFLAGS, (X86cmp (and (loadi32 addr:$src1), imm:$src2),
1336 } // Defs = [EFLAGS]