1 //===-- X86EncodingOptimization.cpp - X86 Encoding optimization -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains the implementation of the X86 encoding optimization
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "X86EncodingOptimization.h"
14 #include "X86BaseInfo.h"
15 #include "llvm/MC/MCExpr.h"
16 #include "llvm/MC/MCInst.h"
17 #include "llvm/MC/MCInstrDesc.h"
18 #include "llvm/Support/Casting.h"
19
20 using namespace llvm;
21
optimizeInstFromVEX3ToVEX2(MCInst & MI,const MCInstrDesc & Desc)22 bool X86::optimizeInstFromVEX3ToVEX2(MCInst &MI, const MCInstrDesc &Desc) {
23 unsigned OpIdx1, OpIdx2;
24 unsigned Opcode = MI.getOpcode();
25 unsigned NewOpc = 0;
26 #define FROM_TO(FROM, TO, IDX1, IDX2) \
27 case X86::FROM: \
28 NewOpc = X86::TO; \
29 OpIdx1 = IDX1; \
30 OpIdx2 = IDX2; \
31 break;
32 #define TO_REV(FROM) FROM_TO(FROM, FROM##_REV, 0, 1)
33 switch (Opcode) {
34 default: {
35 // If the instruction is a commutable arithmetic instruction we might be
36 // able to commute the operands to get a 2 byte VEX prefix.
37 uint64_t TSFlags = Desc.TSFlags;
38 if (!Desc.isCommutable() || (TSFlags & X86II::EncodingMask) != X86II::VEX ||
39 (TSFlags & X86II::OpMapMask) != X86II::TB ||
40 (TSFlags & X86II::FormMask) != X86II::MRMSrcReg ||
41 (TSFlags & X86II::REX_W) || !(TSFlags & X86II::VEX_4V) ||
42 MI.getNumOperands() != 3)
43 return false;
44 // These two are not truly commutable.
45 if (Opcode == X86::VMOVHLPSrr || Opcode == X86::VUNPCKHPDrr)
46 return false;
47 OpIdx1 = 1;
48 OpIdx2 = 2;
49 break;
50 }
51 case X86::VCMPPDrri:
52 case X86::VCMPPDYrri:
53 case X86::VCMPPSrri:
54 case X86::VCMPPSYrri:
55 case X86::VCMPSDrri:
56 case X86::VCMPSSrri: {
57 switch (MI.getOperand(3).getImm() & 0x7) {
58 default:
59 return false;
60 case 0x00: // EQUAL
61 case 0x03: // UNORDERED
62 case 0x04: // NOT EQUAL
63 case 0x07: // ORDERED
64 OpIdx1 = 1;
65 OpIdx2 = 2;
66 break;
67 }
68 break;
69 }
70 // Commute operands to get a smaller encoding by using VEX.R instead of
71 // VEX.B if one of the registers is extended, but other isn't.
72 FROM_TO(VMOVZPQILo2PQIrr, VMOVPQI2QIrr, 0, 1)
73 TO_REV(VMOVAPDrr)
74 TO_REV(VMOVAPDYrr)
75 TO_REV(VMOVAPSrr)
76 TO_REV(VMOVAPSYrr)
77 TO_REV(VMOVDQArr)
78 TO_REV(VMOVDQAYrr)
79 TO_REV(VMOVDQUrr)
80 TO_REV(VMOVDQUYrr)
81 TO_REV(VMOVUPDrr)
82 TO_REV(VMOVUPDYrr)
83 TO_REV(VMOVUPSrr)
84 TO_REV(VMOVUPSYrr)
85 #undef TO_REV
86 #define TO_REV(FROM) FROM_TO(FROM, FROM##_REV, 0, 2)
87 TO_REV(VMOVSDrr)
88 TO_REV(VMOVSSrr)
89 #undef TO_REV
90 #undef FROM_TO
91 }
92 if (X86II::isX86_64ExtendedReg(MI.getOperand(OpIdx1).getReg()) ||
93 !X86II::isX86_64ExtendedReg(MI.getOperand(OpIdx2).getReg()))
94 return false;
95 if (NewOpc)
96 MI.setOpcode(NewOpc);
97 else
98 std::swap(MI.getOperand(OpIdx1), MI.getOperand(OpIdx2));
99 return true;
100 }
101
102 // NOTE: We may write this as an InstAlias if it's only used by AsmParser. See
103 // validateTargetOperandClass.
optimizeShiftRotateWithImmediateOne(MCInst & MI)104 bool X86::optimizeShiftRotateWithImmediateOne(MCInst &MI) {
105 unsigned NewOpc;
106 #define TO_IMM1(FROM) \
107 case X86::FROM##i: \
108 NewOpc = X86::FROM##1; \
109 break; \
110 case X86::FROM##i_EVEX: \
111 NewOpc = X86::FROM##1_EVEX; \
112 break; \
113 case X86::FROM##i_ND: \
114 NewOpc = X86::FROM##1_ND; \
115 break;
116 switch (MI.getOpcode()) {
117 default:
118 return false;
119 TO_IMM1(RCR8r)
120 TO_IMM1(RCR16r)
121 TO_IMM1(RCR32r)
122 TO_IMM1(RCR64r)
123 TO_IMM1(RCL8r)
124 TO_IMM1(RCL16r)
125 TO_IMM1(RCL32r)
126 TO_IMM1(RCL64r)
127 TO_IMM1(RCR8m)
128 TO_IMM1(RCR16m)
129 TO_IMM1(RCR32m)
130 TO_IMM1(RCR64m)
131 TO_IMM1(RCL8m)
132 TO_IMM1(RCL16m)
133 TO_IMM1(RCL32m)
134 TO_IMM1(RCL64m)
135 #undef TO_IMM1
136 #define TO_IMM1(FROM) \
137 case X86::FROM##i: \
138 NewOpc = X86::FROM##1; \
139 break; \
140 case X86::FROM##i_EVEX: \
141 NewOpc = X86::FROM##1_EVEX; \
142 break; \
143 case X86::FROM##i_NF: \
144 NewOpc = X86::FROM##1_NF; \
145 break; \
146 case X86::FROM##i_ND: \
147 NewOpc = X86::FROM##1_ND; \
148 break; \
149 case X86::FROM##i_NF_ND: \
150 NewOpc = X86::FROM##1_NF_ND; \
151 break;
152 TO_IMM1(ROR8r)
153 TO_IMM1(ROR16r)
154 TO_IMM1(ROR32r)
155 TO_IMM1(ROR64r)
156 TO_IMM1(ROL8r)
157 TO_IMM1(ROL16r)
158 TO_IMM1(ROL32r)
159 TO_IMM1(ROL64r)
160 TO_IMM1(SAR8r)
161 TO_IMM1(SAR16r)
162 TO_IMM1(SAR32r)
163 TO_IMM1(SAR64r)
164 TO_IMM1(SHR8r)
165 TO_IMM1(SHR16r)
166 TO_IMM1(SHR32r)
167 TO_IMM1(SHR64r)
168 TO_IMM1(SHL8r)
169 TO_IMM1(SHL16r)
170 TO_IMM1(SHL32r)
171 TO_IMM1(SHL64r)
172 TO_IMM1(ROR8m)
173 TO_IMM1(ROR16m)
174 TO_IMM1(ROR32m)
175 TO_IMM1(ROR64m)
176 TO_IMM1(ROL8m)
177 TO_IMM1(ROL16m)
178 TO_IMM1(ROL32m)
179 TO_IMM1(ROL64m)
180 TO_IMM1(SAR8m)
181 TO_IMM1(SAR16m)
182 TO_IMM1(SAR32m)
183 TO_IMM1(SAR64m)
184 TO_IMM1(SHR8m)
185 TO_IMM1(SHR16m)
186 TO_IMM1(SHR32m)
187 TO_IMM1(SHR64m)
188 TO_IMM1(SHL8m)
189 TO_IMM1(SHL16m)
190 TO_IMM1(SHL32m)
191 TO_IMM1(SHL64m)
192 #undef TO_IMM1
193 }
194 MCOperand &LastOp = MI.getOperand(MI.getNumOperands() - 1);
195 if (!LastOp.isImm() || LastOp.getImm() != 1)
196 return false;
197 MI.setOpcode(NewOpc);
198 MI.erase(&LastOp);
199 return true;
200 }
201
optimizeVPCMPWithImmediateOneOrSix(MCInst & MI)202 bool X86::optimizeVPCMPWithImmediateOneOrSix(MCInst &MI) {
203 unsigned Opc1;
204 unsigned Opc2;
205 #define FROM_TO(FROM, TO1, TO2) \
206 case X86::FROM: \
207 Opc1 = X86::TO1; \
208 Opc2 = X86::TO2; \
209 break;
210 switch (MI.getOpcode()) {
211 default:
212 return false;
213 FROM_TO(VPCMPBZ128rmi, VPCMPEQBZ128rm, VPCMPGTBZ128rm)
214 FROM_TO(VPCMPBZ128rmik, VPCMPEQBZ128rmk, VPCMPGTBZ128rmk)
215 FROM_TO(VPCMPBZ128rri, VPCMPEQBZ128rr, VPCMPGTBZ128rr)
216 FROM_TO(VPCMPBZ128rrik, VPCMPEQBZ128rrk, VPCMPGTBZ128rrk)
217 FROM_TO(VPCMPBZ256rmi, VPCMPEQBZ256rm, VPCMPGTBZ256rm)
218 FROM_TO(VPCMPBZ256rmik, VPCMPEQBZ256rmk, VPCMPGTBZ256rmk)
219 FROM_TO(VPCMPBZ256rri, VPCMPEQBZ256rr, VPCMPGTBZ256rr)
220 FROM_TO(VPCMPBZ256rrik, VPCMPEQBZ256rrk, VPCMPGTBZ256rrk)
221 FROM_TO(VPCMPBZrmi, VPCMPEQBZrm, VPCMPGTBZrm)
222 FROM_TO(VPCMPBZrmik, VPCMPEQBZrmk, VPCMPGTBZrmk)
223 FROM_TO(VPCMPBZrri, VPCMPEQBZrr, VPCMPGTBZrr)
224 FROM_TO(VPCMPBZrrik, VPCMPEQBZrrk, VPCMPGTBZrrk)
225 FROM_TO(VPCMPDZ128rmi, VPCMPEQDZ128rm, VPCMPGTDZ128rm)
226 FROM_TO(VPCMPDZ128rmib, VPCMPEQDZ128rmb, VPCMPGTDZ128rmb)
227 FROM_TO(VPCMPDZ128rmibk, VPCMPEQDZ128rmbk, VPCMPGTDZ128rmbk)
228 FROM_TO(VPCMPDZ128rmik, VPCMPEQDZ128rmk, VPCMPGTDZ128rmk)
229 FROM_TO(VPCMPDZ128rri, VPCMPEQDZ128rr, VPCMPGTDZ128rr)
230 FROM_TO(VPCMPDZ128rrik, VPCMPEQDZ128rrk, VPCMPGTDZ128rrk)
231 FROM_TO(VPCMPDZ256rmi, VPCMPEQDZ256rm, VPCMPGTDZ256rm)
232 FROM_TO(VPCMPDZ256rmib, VPCMPEQDZ256rmb, VPCMPGTDZ256rmb)
233 FROM_TO(VPCMPDZ256rmibk, VPCMPEQDZ256rmbk, VPCMPGTDZ256rmbk)
234 FROM_TO(VPCMPDZ256rmik, VPCMPEQDZ256rmk, VPCMPGTDZ256rmk)
235 FROM_TO(VPCMPDZ256rri, VPCMPEQDZ256rr, VPCMPGTDZ256rr)
236 FROM_TO(VPCMPDZ256rrik, VPCMPEQDZ256rrk, VPCMPGTDZ256rrk)
237 FROM_TO(VPCMPDZrmi, VPCMPEQDZrm, VPCMPGTDZrm)
238 FROM_TO(VPCMPDZrmib, VPCMPEQDZrmb, VPCMPGTDZrmb)
239 FROM_TO(VPCMPDZrmibk, VPCMPEQDZrmbk, VPCMPGTDZrmbk)
240 FROM_TO(VPCMPDZrmik, VPCMPEQDZrmk, VPCMPGTDZrmk)
241 FROM_TO(VPCMPDZrri, VPCMPEQDZrr, VPCMPGTDZrr)
242 FROM_TO(VPCMPDZrrik, VPCMPEQDZrrk, VPCMPGTDZrrk)
243 FROM_TO(VPCMPQZ128rmi, VPCMPEQQZ128rm, VPCMPGTQZ128rm)
244 FROM_TO(VPCMPQZ128rmib, VPCMPEQQZ128rmb, VPCMPGTQZ128rmb)
245 FROM_TO(VPCMPQZ128rmibk, VPCMPEQQZ128rmbk, VPCMPGTQZ128rmbk)
246 FROM_TO(VPCMPQZ128rmik, VPCMPEQQZ128rmk, VPCMPGTQZ128rmk)
247 FROM_TO(VPCMPQZ128rri, VPCMPEQQZ128rr, VPCMPGTQZ128rr)
248 FROM_TO(VPCMPQZ128rrik, VPCMPEQQZ128rrk, VPCMPGTQZ128rrk)
249 FROM_TO(VPCMPQZ256rmi, VPCMPEQQZ256rm, VPCMPGTQZ256rm)
250 FROM_TO(VPCMPQZ256rmib, VPCMPEQQZ256rmb, VPCMPGTQZ256rmb)
251 FROM_TO(VPCMPQZ256rmibk, VPCMPEQQZ256rmbk, VPCMPGTQZ256rmbk)
252 FROM_TO(VPCMPQZ256rmik, VPCMPEQQZ256rmk, VPCMPGTQZ256rmk)
253 FROM_TO(VPCMPQZ256rri, VPCMPEQQZ256rr, VPCMPGTQZ256rr)
254 FROM_TO(VPCMPQZ256rrik, VPCMPEQQZ256rrk, VPCMPGTQZ256rrk)
255 FROM_TO(VPCMPQZrmi, VPCMPEQQZrm, VPCMPGTQZrm)
256 FROM_TO(VPCMPQZrmib, VPCMPEQQZrmb, VPCMPGTQZrmb)
257 FROM_TO(VPCMPQZrmibk, VPCMPEQQZrmbk, VPCMPGTQZrmbk)
258 FROM_TO(VPCMPQZrmik, VPCMPEQQZrmk, VPCMPGTQZrmk)
259 FROM_TO(VPCMPQZrri, VPCMPEQQZrr, VPCMPGTQZrr)
260 FROM_TO(VPCMPQZrrik, VPCMPEQQZrrk, VPCMPGTQZrrk)
261 FROM_TO(VPCMPWZ128rmi, VPCMPEQWZ128rm, VPCMPGTWZ128rm)
262 FROM_TO(VPCMPWZ128rmik, VPCMPEQWZ128rmk, VPCMPGTWZ128rmk)
263 FROM_TO(VPCMPWZ128rri, VPCMPEQWZ128rr, VPCMPGTWZ128rr)
264 FROM_TO(VPCMPWZ128rrik, VPCMPEQWZ128rrk, VPCMPGTWZ128rrk)
265 FROM_TO(VPCMPWZ256rmi, VPCMPEQWZ256rm, VPCMPGTWZ256rm)
266 FROM_TO(VPCMPWZ256rmik, VPCMPEQWZ256rmk, VPCMPGTWZ256rmk)
267 FROM_TO(VPCMPWZ256rri, VPCMPEQWZ256rr, VPCMPGTWZ256rr)
268 FROM_TO(VPCMPWZ256rrik, VPCMPEQWZ256rrk, VPCMPGTWZ256rrk)
269 FROM_TO(VPCMPWZrmi, VPCMPEQWZrm, VPCMPGTWZrm)
270 FROM_TO(VPCMPWZrmik, VPCMPEQWZrmk, VPCMPGTWZrmk)
271 FROM_TO(VPCMPWZrri, VPCMPEQWZrr, VPCMPGTWZrr)
272 FROM_TO(VPCMPWZrrik, VPCMPEQWZrrk, VPCMPGTWZrrk)
273 #undef FROM_TO
274 }
275 MCOperand &LastOp = MI.getOperand(MI.getNumOperands() - 1);
276 int64_t Imm = LastOp.getImm();
277 unsigned NewOpc;
278 if (Imm == 0)
279 NewOpc = Opc1;
280 else if(Imm == 6)
281 NewOpc = Opc2;
282 else
283 return false;
284 MI.setOpcode(NewOpc);
285 MI.erase(&LastOp);
286 return true;
287 }
288
optimizeMOVSX(MCInst & MI)289 bool X86::optimizeMOVSX(MCInst &MI) {
290 unsigned NewOpc;
291 #define FROM_TO(FROM, TO, R0, R1) \
292 case X86::FROM: \
293 if (MI.getOperand(0).getReg() != X86::R0 || \
294 MI.getOperand(1).getReg() != X86::R1) \
295 return false; \
296 NewOpc = X86::TO; \
297 break;
298 switch (MI.getOpcode()) {
299 default:
300 return false;
301 FROM_TO(MOVSX16rr8, CBW, AX, AL) // movsbw %al, %ax --> cbtw
302 FROM_TO(MOVSX32rr16, CWDE, EAX, AX) // movswl %ax, %eax --> cwtl
303 FROM_TO(MOVSX64rr32, CDQE, RAX, EAX) // movslq %eax, %rax --> cltq
304 #undef FROM_TO
305 }
306 MI.clear();
307 MI.setOpcode(NewOpc);
308 return true;
309 }
310
optimizeINCDEC(MCInst & MI,bool In64BitMode)311 bool X86::optimizeINCDEC(MCInst &MI, bool In64BitMode) {
312 if (In64BitMode)
313 return false;
314 unsigned NewOpc;
315 // If we aren't in 64-bit mode we can use the 1-byte inc/dec instructions.
316 #define FROM_TO(FROM, TO) \
317 case X86::FROM: \
318 NewOpc = X86::TO; \
319 break;
320 switch (MI.getOpcode()) {
321 default:
322 return false;
323 FROM_TO(DEC16r, DEC16r_alt)
324 FROM_TO(DEC32r, DEC32r_alt)
325 FROM_TO(INC16r, INC16r_alt)
326 FROM_TO(INC32r, INC32r_alt)
327 }
328 MI.setOpcode(NewOpc);
329 return true;
330 }
331
isARegister(unsigned Reg)332 static bool isARegister(unsigned Reg) {
333 return Reg == X86::AL || Reg == X86::AX || Reg == X86::EAX || Reg == X86::RAX;
334 }
335
336 /// Simplify things like MOV32rm to MOV32o32a.
optimizeMOV(MCInst & MI,bool In64BitMode)337 bool X86::optimizeMOV(MCInst &MI, bool In64BitMode) {
338 // Don't make these simplifications in 64-bit mode; other assemblers don't
339 // perform them because they make the code larger.
340 if (In64BitMode)
341 return false;
342 unsigned NewOpc;
343 // We don't currently select the correct instruction form for instructions
344 // which have a short %eax, etc. form. Handle this by custom lowering, for
345 // now.
346 //
347 // Note, we are currently not handling the following instructions:
348 // MOV64ao8, MOV64o8a
349 // XCHG16ar, XCHG32ar, XCHG64ar
350 switch (MI.getOpcode()) {
351 default:
352 return false;
353 FROM_TO(MOV8mr_NOREX, MOV8o32a)
354 FROM_TO(MOV8mr, MOV8o32a)
355 FROM_TO(MOV8rm_NOREX, MOV8ao32)
356 FROM_TO(MOV8rm, MOV8ao32)
357 FROM_TO(MOV16mr, MOV16o32a)
358 FROM_TO(MOV16rm, MOV16ao32)
359 FROM_TO(MOV32mr, MOV32o32a)
360 FROM_TO(MOV32rm, MOV32ao32)
361 }
362 bool IsStore = MI.getOperand(0).isReg() && MI.getOperand(1).isReg();
363 unsigned AddrBase = IsStore;
364 unsigned RegOp = IsStore ? 0 : 5;
365 unsigned AddrOp = AddrBase + 3;
366 // Check whether the destination register can be fixed.
367 unsigned Reg = MI.getOperand(RegOp).getReg();
368 if (!isARegister(Reg))
369 return false;
370 // Check whether this is an absolute address.
371 // FIXME: We know TLVP symbol refs aren't, but there should be a better way
372 // to do this here.
373 bool Absolute = true;
374 if (MI.getOperand(AddrOp).isExpr()) {
375 const MCExpr *MCE = MI.getOperand(AddrOp).getExpr();
376 if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(MCE))
377 if (SRE->getKind() == MCSymbolRefExpr::VK_TLVP)
378 Absolute = false;
379 }
380 if (Absolute && (MI.getOperand(AddrBase + X86::AddrBaseReg).getReg() != 0 ||
381 MI.getOperand(AddrBase + X86::AddrScaleAmt).getImm() != 1 ||
382 MI.getOperand(AddrBase + X86::AddrIndexReg).getReg() != 0))
383 return false;
384 // If so, rewrite the instruction.
385 MCOperand Saved = MI.getOperand(AddrOp);
386 MCOperand Seg = MI.getOperand(AddrBase + X86::AddrSegmentReg);
387 MI.clear();
388 MI.setOpcode(NewOpc);
389 MI.addOperand(Saved);
390 MI.addOperand(Seg);
391 return true;
392 }
393
394 /// Simplify FOO $imm, %{al,ax,eax,rax} to FOO $imm, for instruction with
395 /// a short fixed-register form.
optimizeToFixedRegisterForm(MCInst & MI)396 static bool optimizeToFixedRegisterForm(MCInst &MI) {
397 unsigned NewOpc;
398 switch (MI.getOpcode()) {
399 default:
400 return false;
401 FROM_TO(ADC8ri, ADC8i8)
402 FROM_TO(ADC16ri, ADC16i16)
403 FROM_TO(ADC32ri, ADC32i32)
404 FROM_TO(ADC64ri32, ADC64i32)
405 FROM_TO(ADD8ri, ADD8i8)
406 FROM_TO(ADD16ri, ADD16i16)
407 FROM_TO(ADD32ri, ADD32i32)
408 FROM_TO(ADD64ri32, ADD64i32)
409 FROM_TO(AND8ri, AND8i8)
410 FROM_TO(AND16ri, AND16i16)
411 FROM_TO(AND32ri, AND32i32)
412 FROM_TO(AND64ri32, AND64i32)
413 FROM_TO(CMP8ri, CMP8i8)
414 FROM_TO(CMP16ri, CMP16i16)
415 FROM_TO(CMP32ri, CMP32i32)
416 FROM_TO(CMP64ri32, CMP64i32)
417 FROM_TO(OR8ri, OR8i8)
418 FROM_TO(OR16ri, OR16i16)
419 FROM_TO(OR32ri, OR32i32)
420 FROM_TO(OR64ri32, OR64i32)
421 FROM_TO(SBB8ri, SBB8i8)
422 FROM_TO(SBB16ri, SBB16i16)
423 FROM_TO(SBB32ri, SBB32i32)
424 FROM_TO(SBB64ri32, SBB64i32)
425 FROM_TO(SUB8ri, SUB8i8)
426 FROM_TO(SUB16ri, SUB16i16)
427 FROM_TO(SUB32ri, SUB32i32)
428 FROM_TO(SUB64ri32, SUB64i32)
429 FROM_TO(TEST8ri, TEST8i8)
430 FROM_TO(TEST16ri, TEST16i16)
431 FROM_TO(TEST32ri, TEST32i32)
432 FROM_TO(TEST64ri32, TEST64i32)
433 FROM_TO(XOR8ri, XOR8i8)
434 FROM_TO(XOR16ri, XOR16i16)
435 FROM_TO(XOR32ri, XOR32i32)
436 FROM_TO(XOR64ri32, XOR64i32)
437 }
438 // Check whether the destination register can be fixed.
439 unsigned Reg = MI.getOperand(0).getReg();
440 if (!isARegister(Reg))
441 return false;
442
443 // If so, rewrite the instruction.
444 MCOperand Saved = MI.getOperand(MI.getNumOperands() - 1);
445 MI.clear();
446 MI.setOpcode(NewOpc);
447 MI.addOperand(Saved);
448 return true;
449 }
450
getOpcodeForShortImmediateForm(unsigned Opcode)451 unsigned X86::getOpcodeForShortImmediateForm(unsigned Opcode) {
452 #define ENTRY(LONG, SHORT) \
453 case X86::LONG: \
454 return X86::SHORT;
455 switch (Opcode) {
456 default:
457 return Opcode;
458 #include "X86EncodingOptimizationForImmediate.def"
459 }
460 }
461
getOpcodeForLongImmediateForm(unsigned Opcode)462 unsigned X86::getOpcodeForLongImmediateForm(unsigned Opcode) {
463 #define ENTRY(LONG, SHORT) \
464 case X86::SHORT: \
465 return X86::LONG;
466 switch (Opcode) {
467 default:
468 return Opcode;
469 #include "X86EncodingOptimizationForImmediate.def"
470 }
471 }
472
optimizeToShortImmediateForm(MCInst & MI)473 static bool optimizeToShortImmediateForm(MCInst &MI) {
474 unsigned NewOpc;
475 #define ENTRY(LONG, SHORT) \
476 case X86::LONG: \
477 NewOpc = X86::SHORT; \
478 break;
479 switch (MI.getOpcode()) {
480 default:
481 return false;
482 #include "X86EncodingOptimizationForImmediate.def"
483 }
484 unsigned SkipOperands = X86::isCCMPCC(MI.getOpcode()) ? 2 : 0;
485 MCOperand &LastOp = MI.getOperand(MI.getNumOperands() - 1 - SkipOperands);
486 if (LastOp.isExpr()) {
487 const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(LastOp.getExpr());
488 if (!SRE || SRE->getKind() != MCSymbolRefExpr::VK_X86_ABS8)
489 return false;
490 } else if (LastOp.isImm()) {
491 if (!isInt<8>(LastOp.getImm()))
492 return false;
493 }
494 MI.setOpcode(NewOpc);
495 return true;
496 }
497
optimizeToFixedRegisterOrShortImmediateForm(MCInst & MI)498 bool X86::optimizeToFixedRegisterOrShortImmediateForm(MCInst &MI) {
499 // We may optimize twice here.
500 bool ShortImm = optimizeToShortImmediateForm(MI);
501 bool FixedReg = optimizeToFixedRegisterForm(MI);
502 return ShortImm || FixedReg;
503 }
504