diff --git a/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp b/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp --- a/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp +++ b/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "MCTargetDesc/X86BaseInfo.h" +#include "MCTargetDesc/X86InstrOptimization.h" #include "MCTargetDesc/X86IntelInstPrinter.h" #include "MCTargetDesc/X86MCExpr.h" #include "MCTargetDesc/X86MCTargetDesc.h" @@ -3623,7 +3624,12 @@ } bool X86AsmParser::processInstruction(MCInst &Inst, const OperandVector &Ops) { - const MCRegisterInfo *MRI = getContext().getRegisterInfo(); + if (ForcedVEXEncoding != VEXEncoding_VEX3 && + X86::optimizeInstFromVEX3ToVEX2(Inst)) + return true; + + if (X86::optimizeShiftRotateWithImmediateOne(Inst)) + return true; switch (Inst.getOpcode()) { default: return false; @@ -3647,178 +3653,12 @@ } return false; - case X86::VMOVZPQILo2PQIrr: - case X86::VMOVAPDrr: - case X86::VMOVAPDYrr: - case X86::VMOVAPSrr: - case X86::VMOVAPSYrr: - case X86::VMOVDQArr: - case X86::VMOVDQAYrr: - case X86::VMOVDQUrr: - case X86::VMOVDQUYrr: - case X86::VMOVUPDrr: - case X86::VMOVUPDYrr: - case X86::VMOVUPSrr: - case X86::VMOVUPSYrr: { - // We can get a smaller encoding by using VEX.R instead of VEX.B if one of - // the registers is extended, but other isn't. - if (ForcedVEXEncoding == VEXEncoding_VEX3 || - MRI->getEncodingValue(Inst.getOperand(0).getReg()) >= 8 || - MRI->getEncodingValue(Inst.getOperand(1).getReg()) < 8) - return false; - - unsigned NewOpc; - switch (Inst.getOpcode()) { - default: llvm_unreachable("Invalid opcode"); - case X86::VMOVZPQILo2PQIrr: NewOpc = X86::VMOVPQI2QIrr; break; - case X86::VMOVAPDrr: NewOpc = X86::VMOVAPDrr_REV; break; - case X86::VMOVAPDYrr: NewOpc = X86::VMOVAPDYrr_REV; break; - case X86::VMOVAPSrr: NewOpc = X86::VMOVAPSrr_REV; break; - case X86::VMOVAPSYrr: NewOpc = X86::VMOVAPSYrr_REV; break; - case X86::VMOVDQArr: NewOpc = X86::VMOVDQArr_REV; break; - case X86::VMOVDQAYrr: NewOpc = X86::VMOVDQAYrr_REV; break; - case X86::VMOVDQUrr: NewOpc = X86::VMOVDQUrr_REV; break; - case X86::VMOVDQUYrr: NewOpc = X86::VMOVDQUYrr_REV; break; - case X86::VMOVUPDrr: NewOpc = X86::VMOVUPDrr_REV; break; - case X86::VMOVUPDYrr: NewOpc = X86::VMOVUPDYrr_REV; break; - case X86::VMOVUPSrr: NewOpc = X86::VMOVUPSrr_REV; break; - case X86::VMOVUPSYrr: NewOpc = X86::VMOVUPSYrr_REV; break; - } - Inst.setOpcode(NewOpc); - return true; - } - case X86::VMOVSDrr: - case X86::VMOVSSrr: { - // We can get a smaller encoding by using VEX.R instead of VEX.B if one of - // the registers is extended, but other isn't. - if (ForcedVEXEncoding == VEXEncoding_VEX3 || - MRI->getEncodingValue(Inst.getOperand(0).getReg()) >= 8 || - MRI->getEncodingValue(Inst.getOperand(2).getReg()) < 8) - return false; - - unsigned NewOpc; - switch (Inst.getOpcode()) { - default: llvm_unreachable("Invalid opcode"); - case X86::VMOVSDrr: NewOpc = X86::VMOVSDrr_REV; break; - case X86::VMOVSSrr: NewOpc = X86::VMOVSSrr_REV; break; - } - Inst.setOpcode(NewOpc); - return true; - } - case X86::RCR8ri: case X86::RCR16ri: case X86::RCR32ri: case X86::RCR64ri: - case X86::RCL8ri: case X86::RCL16ri: case X86::RCL32ri: case X86::RCL64ri: - case X86::ROR8ri: case X86::ROR16ri: case X86::ROR32ri: case X86::ROR64ri: - case X86::ROL8ri: case X86::ROL16ri: case X86::ROL32ri: case X86::ROL64ri: - case X86::SAR8ri: case X86::SAR16ri: case X86::SAR32ri: case X86::SAR64ri: - case X86::SHR8ri: case X86::SHR16ri: case X86::SHR32ri: case X86::SHR64ri: - case X86::SHL8ri: case X86::SHL16ri: case X86::SHL32ri: case X86::SHL64ri: { - // Optimize s{hr,ar,hl} $1, to "shift ". Similar for rotate. - // FIXME: It would be great if we could just do this with an InstAlias. - if (!Inst.getOperand(2).isImm() || Inst.getOperand(2).getImm() != 1) - return false; - - unsigned NewOpc; - switch (Inst.getOpcode()) { - default: llvm_unreachable("Invalid opcode"); - case X86::RCR8ri: NewOpc = X86::RCR8r1; break; - case X86::RCR16ri: NewOpc = X86::RCR16r1; break; - case X86::RCR32ri: NewOpc = X86::RCR32r1; break; - case X86::RCR64ri: NewOpc = X86::RCR64r1; break; - case X86::RCL8ri: NewOpc = X86::RCL8r1; break; - case X86::RCL16ri: NewOpc = X86::RCL16r1; break; - case X86::RCL32ri: NewOpc = X86::RCL32r1; break; - case X86::RCL64ri: NewOpc = X86::RCL64r1; break; - case X86::ROR8ri: NewOpc = X86::ROR8r1; break; - case X86::ROR16ri: NewOpc = X86::ROR16r1; break; - case X86::ROR32ri: NewOpc = X86::ROR32r1; break; - case X86::ROR64ri: NewOpc = X86::ROR64r1; break; - case X86::ROL8ri: NewOpc = X86::ROL8r1; break; - case X86::ROL16ri: NewOpc = X86::ROL16r1; break; - case X86::ROL32ri: NewOpc = X86::ROL32r1; break; - case X86::ROL64ri: NewOpc = X86::ROL64r1; break; - case X86::SAR8ri: NewOpc = X86::SAR8r1; break; - case X86::SAR16ri: NewOpc = X86::SAR16r1; break; - case X86::SAR32ri: NewOpc = X86::SAR32r1; break; - case X86::SAR64ri: NewOpc = X86::SAR64r1; break; - case X86::SHR8ri: NewOpc = X86::SHR8r1; break; - case X86::SHR16ri: NewOpc = X86::SHR16r1; break; - case X86::SHR32ri: NewOpc = X86::SHR32r1; break; - case X86::SHR64ri: NewOpc = X86::SHR64r1; break; - case X86::SHL8ri: NewOpc = X86::SHL8r1; break; - case X86::SHL16ri: NewOpc = X86::SHL16r1; break; - case X86::SHL32ri: NewOpc = X86::SHL32r1; break; - case X86::SHL64ri: NewOpc = X86::SHL64r1; break; - } - - MCInst TmpInst; - TmpInst.setOpcode(NewOpc); - TmpInst.addOperand(Inst.getOperand(0)); - TmpInst.addOperand(Inst.getOperand(1)); - Inst = TmpInst; - return true; - } - case X86::RCR8mi: case X86::RCR16mi: case X86::RCR32mi: case X86::RCR64mi: - case X86::RCL8mi: case X86::RCL16mi: case X86::RCL32mi: case X86::RCL64mi: - case X86::ROR8mi: case X86::ROR16mi: case X86::ROR32mi: case X86::ROR64mi: - case X86::ROL8mi: case X86::ROL16mi: case X86::ROL32mi: case X86::ROL64mi: - case X86::SAR8mi: case X86::SAR16mi: case X86::SAR32mi: case X86::SAR64mi: - case X86::SHR8mi: case X86::SHR16mi: case X86::SHR32mi: case X86::SHR64mi: - case X86::SHL8mi: case X86::SHL16mi: case X86::SHL32mi: case X86::SHL64mi: { - // Optimize s{hr,ar,hl} $1, to "shift ". Similar for rotate. - // FIXME: It would be great if we could just do this with an InstAlias. - if (!Inst.getOperand(X86::AddrNumOperands).isImm() || - Inst.getOperand(X86::AddrNumOperands).getImm() != 1) - return false; - - unsigned NewOpc; - switch (Inst.getOpcode()) { - default: llvm_unreachable("Invalid opcode"); - case X86::RCR8mi: NewOpc = X86::RCR8m1; break; - case X86::RCR16mi: NewOpc = X86::RCR16m1; break; - case X86::RCR32mi: NewOpc = X86::RCR32m1; break; - case X86::RCR64mi: NewOpc = X86::RCR64m1; break; - case X86::RCL8mi: NewOpc = X86::RCL8m1; break; - case X86::RCL16mi: NewOpc = X86::RCL16m1; break; - case X86::RCL32mi: NewOpc = X86::RCL32m1; break; - case X86::RCL64mi: NewOpc = X86::RCL64m1; break; - case X86::ROR8mi: NewOpc = X86::ROR8m1; break; - case X86::ROR16mi: NewOpc = X86::ROR16m1; break; - case X86::ROR32mi: NewOpc = X86::ROR32m1; break; - case X86::ROR64mi: NewOpc = X86::ROR64m1; break; - case X86::ROL8mi: NewOpc = X86::ROL8m1; break; - case X86::ROL16mi: NewOpc = X86::ROL16m1; break; - case X86::ROL32mi: NewOpc = X86::ROL32m1; break; - case X86::ROL64mi: NewOpc = X86::ROL64m1; break; - case X86::SAR8mi: NewOpc = X86::SAR8m1; break; - case X86::SAR16mi: NewOpc = X86::SAR16m1; break; - case X86::SAR32mi: NewOpc = X86::SAR32m1; break; - case X86::SAR64mi: NewOpc = X86::SAR64m1; break; - case X86::SHR8mi: NewOpc = X86::SHR8m1; break; - case X86::SHR16mi: NewOpc = X86::SHR16m1; break; - case X86::SHR32mi: NewOpc = X86::SHR32m1; break; - case X86::SHR64mi: NewOpc = X86::SHR64m1; break; - case X86::SHL8mi: NewOpc = X86::SHL8m1; break; - case X86::SHL16mi: NewOpc = X86::SHL16m1; break; - case X86::SHL32mi: NewOpc = X86::SHL32m1; break; - case X86::SHL64mi: NewOpc = X86::SHL64m1; break; - } - - MCInst TmpInst; - TmpInst.setOpcode(NewOpc); - for (int i = 0; i != X86::AddrNumOperands; ++i) - TmpInst.addOperand(Inst.getOperand(i)); - Inst = TmpInst; - return true; - } case X86::INT: { - // Transforms "int $3" into "int3" as a size optimization. We can't write an - // instalias with an immediate operand yet. + // Transforms "int $3" into "int3" as a size optimization. if (!Inst.getOperand(0).isImm() || Inst.getOperand(0).getImm() != 3) return false; - - MCInst TmpInst; - TmpInst.setOpcode(X86::INT3); - Inst = TmpInst; + Inst.erase(&Inst.getOperand(Inst.getNumOperands() - 1)); + Inst.setOpcode(X86::INT3); return true; } } diff --git a/llvm/lib/Target/X86/MCTargetDesc/CMakeLists.txt b/llvm/lib/Target/X86/MCTargetDesc/CMakeLists.txt --- a/llvm/lib/Target/X86/MCTargetDesc/CMakeLists.txt +++ b/llvm/lib/Target/X86/MCTargetDesc/CMakeLists.txt @@ -4,6 +4,7 @@ X86InstComments.cpp X86InstPrinterCommon.cpp X86InstrRelaxTables.cpp + X86InstrOptimization.cpp X86ShuffleDecode.cpp X86AsmBackend.cpp X86MCTargetDesc.cpp diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86InstrOptimization.h b/llvm/lib/Target/X86/MCTargetDesc/X86InstrOptimization.h new file mode 100644 --- /dev/null +++ b/llvm/lib/Target/X86/MCTargetDesc/X86InstrOptimization.h @@ -0,0 +1,22 @@ +//===-- X86InstrOptimization.h - X86 MCInst optimization --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains the declarations of the X86 MCInst optimization +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIB_TARGET_X86_X86INSTROPTIMIZATION_H +#define LLVM_LIB_TARGET_X86_X86INSTROPTIMIZATION_H +namespace llvm { +class MCInst; +namespace X86 { +bool optimizeInstFromVEX3ToVEX2(MCInst &MI); +bool optimizeShiftRotateWithImmediateOne(MCInst &MI); +} // namespace X86 +} // namespace llvm +#endif diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86InstrOptimization.cpp b/llvm/lib/Target/X86/MCTargetDesc/X86InstrOptimization.cpp new file mode 100644 --- /dev/null +++ b/llvm/lib/Target/X86/MCTargetDesc/X86InstrOptimization.cpp @@ -0,0 +1,127 @@ +//===-- X86InstrOptimization.cpp - X86 MCInst optimization ------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains the implementation of the X86 MCInst optimization +// +//===----------------------------------------------------------------------===// + +#include "X86InstrOptimization.h" +#include "X86BaseInfo.h" +#include "llvm/MC/MCInst.h" + +using namespace llvm; +bool X86::optimizeInstFromVEX3ToVEX2(MCInst &MI) { +#define FROM_TO_RETURN(FROM, TO, NUM1, NUM2) \ + case X86::FROM: \ + if (X86II::isX86_64ExtendedReg(MI.getOperand(NUM1).getReg()) || \ + !X86II::isX86_64ExtendedReg(MI.getOperand(NUM2).getReg())) \ + return false; \ + MI.setOpcode(X86::TO); \ + return true; +#define TO_REV_RETURN(FROM) FROM_TO_RETURN(FROM, FROM##_REV, 0, 1) + switch (MI.getOpcode()) { + default: + return false; + // Commute operands to get a smaller encoding by using VEX.R instead of + // VEX.B if one of the registers is extended, but other isn't. + FROM_TO_RETURN(VMOVZPQILo2PQIrr, VMOVPQI2QIrr, 0, 1) + TO_REV_RETURN(VMOVAPDrr) + TO_REV_RETURN(VMOVAPDYrr) + TO_REV_RETURN(VMOVAPSrr) + TO_REV_RETURN(VMOVAPSYrr) + TO_REV_RETURN(VMOVDQArr) + TO_REV_RETURN(VMOVDQAYrr) + TO_REV_RETURN(VMOVDQUrr) + TO_REV_RETURN(VMOVDQUYrr) + TO_REV_RETURN(VMOVUPDrr) + TO_REV_RETURN(VMOVUPDYrr) + TO_REV_RETURN(VMOVUPSrr) + TO_REV_RETURN(VMOVUPSYrr) +#undef TO_REV_RETURN +#define TO_REV_RETURN(FROM) FROM_TO_RETURN(FROM, FROM##_REV, 0, 2) + TO_REV_RETURN(VMOVSDrr) + TO_REV_RETURN(VMOVSSrr) +#undef TO_REV_RETURN +#undef FROM_TO_RETURN + } +} + +bool X86::optimizeShiftRotateWithImmediateOne(MCInst &MI) { + auto E = MI.end(); + if (MI.begin() == E) + return false; + auto LastOpIt = std::prev(E); + const MCOperand &LastOp = *LastOpIt; +#define FROM_TO_RETURN(FROM, TO) \ + case X86::FROM: \ + if (!LastOp.isImm() || LastOp.getImm() != 1) \ + return false; \ + MI.setOpcode(X86::TO); \ + MI.erase(LastOpIt); \ + return true; + switch (MI.getOpcode()) { + default: + return false; + FROM_TO_RETURN(RCR8ri, RCR8r1) + FROM_TO_RETURN(RCR16ri, RCR16r1) + FROM_TO_RETURN(RCR32ri, RCR32r1) + FROM_TO_RETURN(RCR64ri, RCR64r1) + FROM_TO_RETURN(RCL8ri, RCL8r1) + FROM_TO_RETURN(RCL16ri, RCL16r1) + FROM_TO_RETURN(RCL32ri, RCL32r1) + FROM_TO_RETURN(RCL64ri, RCL64r1) + FROM_TO_RETURN(ROR8ri, ROR8r1) + FROM_TO_RETURN(ROR16ri, ROR16r1) + FROM_TO_RETURN(ROR32ri, ROR32r1) + FROM_TO_RETURN(ROR64ri, ROR64r1) + FROM_TO_RETURN(ROL8ri, ROL8r1) + FROM_TO_RETURN(ROL16ri, ROL16r1) + FROM_TO_RETURN(ROL32ri, ROL32r1) + FROM_TO_RETURN(ROL64ri, ROL64r1) + FROM_TO_RETURN(SAR8ri, SAR8r1) + FROM_TO_RETURN(SAR16ri, SAR16r1) + FROM_TO_RETURN(SAR32ri, SAR32r1) + FROM_TO_RETURN(SAR64ri, SAR64r1) + FROM_TO_RETURN(SHR8ri, SHR8r1) + FROM_TO_RETURN(SHR16ri, SHR16r1) + FROM_TO_RETURN(SHR32ri, SHR32r1) + FROM_TO_RETURN(SHR64ri, SHR64r1) + FROM_TO_RETURN(SHL8ri, SHL8r1) + FROM_TO_RETURN(SHL16ri, SHL16r1) + FROM_TO_RETURN(SHL32ri, SHL32r1) + FROM_TO_RETURN(SHL64ri, SHL64r1) + FROM_TO_RETURN(RCR8mi, RCR8m1) + FROM_TO_RETURN(RCR16mi, RCR16m1) + FROM_TO_RETURN(RCR32mi, RCR32m1) + FROM_TO_RETURN(RCR64mi, RCR64m1) + FROM_TO_RETURN(RCL8mi, RCL8m1) + FROM_TO_RETURN(RCL16mi, RCL16m1) + FROM_TO_RETURN(RCL32mi, RCL32m1) + FROM_TO_RETURN(RCL64mi, RCL64m1) + FROM_TO_RETURN(ROR8mi, ROR8m1) + FROM_TO_RETURN(ROR16mi, ROR16m1) + FROM_TO_RETURN(ROR32mi, ROR32m1) + FROM_TO_RETURN(ROR64mi, ROR64m1) + FROM_TO_RETURN(ROL8mi, ROL8m1) + FROM_TO_RETURN(ROL16mi, ROL16m1) + FROM_TO_RETURN(ROL32mi, ROL32m1) + FROM_TO_RETURN(ROL64mi, ROL64m1) + FROM_TO_RETURN(SAR8mi, SAR8m1) + FROM_TO_RETURN(SAR16mi, SAR16m1) + FROM_TO_RETURN(SAR32mi, SAR32m1) + FROM_TO_RETURN(SAR64mi, SAR64m1) + FROM_TO_RETURN(SHR8mi, SHR8m1) + FROM_TO_RETURN(SHR16mi, SHR16m1) + FROM_TO_RETURN(SHR32mi, SHR32m1) + FROM_TO_RETURN(SHR64mi, SHR64m1) + FROM_TO_RETURN(SHL8mi, SHL8m1) + FROM_TO_RETURN(SHL16mi, SHL16m1) + FROM_TO_RETURN(SHL32mi, SHL32m1) + FROM_TO_RETURN(SHL64mi, SHL64m1) + } +} diff --git a/llvm/lib/Target/X86/X86InstrAsmAlias.td b/llvm/lib/Target/X86/X86InstrAsmAlias.td --- a/llvm/lib/Target/X86/X86InstrAsmAlias.td +++ b/llvm/lib/Target/X86/X86InstrAsmAlias.td @@ -551,34 +551,6 @@ def : InstAlias<"shrd{l}\t{$reg, $mem|$mem, $reg}", (SHRD32mrCL i32mem:$mem, GR32:$reg), 0>; def : InstAlias<"shrd{q}\t{$reg, $mem|$mem, $reg}", (SHRD64mrCL i64mem:$mem, GR64:$reg), 0>; -/* FIXME: This is disabled because the asm matcher is currently incapable of - * matching a fixed immediate like $1. -// "shl X, $1" is an alias for "shl X". -multiclass ShiftRotateByOneAlias { - def : InstAlias(!strconcat(Opc, "8r1")) GR8:$op)>; - def : InstAlias(!strconcat(Opc, "16r1")) GR16:$op)>; - def : InstAlias(!strconcat(Opc, "32r1")) GR32:$op)>; - def : InstAlias(!strconcat(Opc, "64r1")) GR64:$op)>; - def : InstAlias(!strconcat(Opc, "8m1")) i8mem:$op)>; - def : InstAlias(!strconcat(Opc, "16m1")) i16mem:$op)>; - def : InstAlias(!strconcat(Opc, "32m1")) i32mem:$op)>; - def : InstAlias(!strconcat(Opc, "64m1")) i64mem:$op)>; -} - -defm : ShiftRotateByOneAlias<"rcl", "RCL">; -defm : ShiftRotateByOneAlias<"rcr", "RCR">; -defm : ShiftRotateByOneAlias<"rol", "ROL">; -defm : ShiftRotateByOneAlias<"ror", "ROR">; -FIXME */ - // test: We accept "testX , " and "testX , " as synonyms. def : InstAlias<"test{b}\t{$mem, $val|$val, $mem}", (TEST8mr i8mem :$mem, GR8 :$val), 0>; diff --git a/llvm/lib/Target/X86/X86MCInstLower.cpp b/llvm/lib/Target/X86/X86MCInstLower.cpp --- a/llvm/lib/Target/X86/X86MCInstLower.cpp +++ b/llvm/lib/Target/X86/X86MCInstLower.cpp @@ -14,6 +14,7 @@ #include "MCTargetDesc/X86ATTInstPrinter.h" #include "MCTargetDesc/X86BaseInfo.h" #include "MCTargetDesc/X86InstComments.h" +#include "MCTargetDesc/X86InstrOptimization.h" #include "MCTargetDesc/X86ShuffleDecode.h" #include "MCTargetDesc/X86TargetStreamer.h" #include "X86AsmPrinter.h" @@ -501,6 +502,9 @@ if (auto MaybeMCOp = LowerMachineOperand(MI, MO)) OutMI.addOperand(*MaybeMCOp); + if (X86::optimizeInstFromVEX3ToVEX2(OutMI)) + return; + // Handle a few special cases to eliminate operand modifiers. switch (OutMI.getOpcode()) { case X86::LEA64_32r: @@ -534,59 +538,6 @@ break; } - // Commute operands to get a smaller encoding by using VEX.R instead of VEX.B - // if one of the registers is extended, but other isn't. - case X86::VMOVZPQILo2PQIrr: - case X86::VMOVAPDrr: - case X86::VMOVAPDYrr: - case X86::VMOVAPSrr: - case X86::VMOVAPSYrr: - case X86::VMOVDQArr: - case X86::VMOVDQAYrr: - case X86::VMOVDQUrr: - case X86::VMOVDQUYrr: - case X86::VMOVUPDrr: - case X86::VMOVUPDYrr: - case X86::VMOVUPSrr: - case X86::VMOVUPSYrr: { - if (!X86II::isX86_64ExtendedReg(OutMI.getOperand(0).getReg()) && - X86II::isX86_64ExtendedReg(OutMI.getOperand(1).getReg())) { - unsigned NewOpc; - switch (OutMI.getOpcode()) { - default: llvm_unreachable("Invalid opcode"); - case X86::VMOVZPQILo2PQIrr: NewOpc = X86::VMOVPQI2QIrr; break; - case X86::VMOVAPDrr: NewOpc = X86::VMOVAPDrr_REV; break; - case X86::VMOVAPDYrr: NewOpc = X86::VMOVAPDYrr_REV; break; - case X86::VMOVAPSrr: NewOpc = X86::VMOVAPSrr_REV; break; - case X86::VMOVAPSYrr: NewOpc = X86::VMOVAPSYrr_REV; break; - case X86::VMOVDQArr: NewOpc = X86::VMOVDQArr_REV; break; - case X86::VMOVDQAYrr: NewOpc = X86::VMOVDQAYrr_REV; break; - case X86::VMOVDQUrr: NewOpc = X86::VMOVDQUrr_REV; break; - case X86::VMOVDQUYrr: NewOpc = X86::VMOVDQUYrr_REV; break; - case X86::VMOVUPDrr: NewOpc = X86::VMOVUPDrr_REV; break; - case X86::VMOVUPDYrr: NewOpc = X86::VMOVUPDYrr_REV; break; - case X86::VMOVUPSrr: NewOpc = X86::VMOVUPSrr_REV; break; - case X86::VMOVUPSYrr: NewOpc = X86::VMOVUPSYrr_REV; break; - } - OutMI.setOpcode(NewOpc); - } - break; - } - case X86::VMOVSDrr: - case X86::VMOVSSrr: { - if (!X86II::isX86_64ExtendedReg(OutMI.getOperand(0).getReg()) && - X86II::isX86_64ExtendedReg(OutMI.getOperand(2).getReg())) { - unsigned NewOpc; - switch (OutMI.getOpcode()) { - default: llvm_unreachable("Invalid opcode"); - case X86::VMOVSDrr: NewOpc = X86::VMOVSDrr_REV; break; - case X86::VMOVSSrr: NewOpc = X86::VMOVSSrr_REV; break; - } - OutMI.setOpcode(NewOpc); - } - break; - } - case X86::VPCMPBZ128rmi: case X86::VPCMPBZ128rmik: case X86::VPCMPBZ128rri: case X86::VPCMPBZ128rrik: case X86::VPCMPBZ256rmi: case X86::VPCMPBZ256rmik: