[llvm] bf8f684 - Revert "[RFC][X86][MemFold] Upgrade the mechanism of auto-generated Memory Folding Table"
Vitaly Buka via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 16 23:16:13 PDT 2023
Author: Vitaly Buka
Date: 2023-03-16T23:16:00-07:00
New Revision: bf8f684efff34975b5f091f2cdcb81b52b53b79c
URL: https://github.com/llvm/llvm-project/commit/bf8f684efff34975b5f091f2cdcb81b52b53b79c
DIFF: https://github.com/llvm/llvm-project/commit/bf8f684efff34975b5f091f2cdcb81b52b53b79c.diff
LOG: Revert "[RFC][X86][MemFold] Upgrade the mechanism of auto-generated Memory Folding Table"
X86FoldTablesEmitter.cpp:386:26: runtime error: shift exponent -1 is negative
This reverts commit ca4c5331823755d5f7ae28a8bcaaa0fed21cf762.
Added:
Modified:
llvm/lib/Target/X86/X86InstrFoldTables.h
llvm/utils/TableGen/X86FoldTablesEmitter.cpp
Removed:
llvm/include/llvm/Support/X86FoldTablesUtils.h
llvm/test/TableGen/x86-auto-memfold.td
llvm/utils/TableGen/X86FoldTablesEmitterManualMapSet.inc
################################################################################
diff --git a/llvm/include/llvm/Support/X86FoldTablesUtils.h b/llvm/include/llvm/Support/X86FoldTablesUtils.h
deleted file mode 100644
index 4829700183139..0000000000000
--- a/llvm/include/llvm/Support/X86FoldTablesUtils.h
+++ /dev/null
@@ -1,59 +0,0 @@
-//===-- X86FoldTablesUtils.h ------------------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_X86FOLDTABLESUTILS_H
-#define LLVM_SUPPORT_X86FOLDTABLESUTILS_H
-
-namespace {
-enum {
- // Select which memory operand is being unfolded.
- // (stored in bits 0 - 2)
- TB_INDEX_0 = 0,
- TB_INDEX_1 = 1,
- TB_INDEX_2 = 2,
- TB_INDEX_3 = 3,
- TB_INDEX_4 = 4,
- TB_INDEX_MASK = 0x7,
-
- // Do not insert the reverse map (MemOp -> RegOp) into the table.
- // This may be needed because there is a many -> one mapping.
- TB_NO_REVERSE = 1 << 3,
-
- // Do not insert the forward map (RegOp -> MemOp) into the table.
- // This is needed for Native Client, which prohibits branch
- // instructions from using a memory operand.
- TB_NO_FORWARD = 1 << 4,
-
- TB_FOLDED_LOAD = 1 << 5,
- TB_FOLDED_STORE = 1 << 6,
- TB_FOLDED_BCAST = 1 << 7,
-
- // Minimum alignment required for load/store.
- // Used for RegOp->MemOp conversion. Encoded as Log2(Align) + 1 to allow 0
- // to mean align of 0.
- // (stored in bits 8 - 11)
- TB_ALIGN_SHIFT = 8,
- TB_ALIGN_NONE = 0 << TB_ALIGN_SHIFT,
- TB_ALIGN_16 = 5 << TB_ALIGN_SHIFT,
- TB_ALIGN_32 = 6 << TB_ALIGN_SHIFT,
- TB_ALIGN_64 = 7 << TB_ALIGN_SHIFT,
- TB_ALIGN_MASK = 0xf << TB_ALIGN_SHIFT,
-
- // Broadcast type.
- // (stored in bits 12 - 13)
- TB_BCAST_TYPE_SHIFT = 12,
- TB_BCAST_D = 0 << TB_BCAST_TYPE_SHIFT,
- TB_BCAST_Q = 1 << TB_BCAST_TYPE_SHIFT,
- TB_BCAST_SS = 2 << TB_BCAST_TYPE_SHIFT,
- TB_BCAST_SD = 3 << TB_BCAST_TYPE_SHIFT,
- TB_BCAST_MASK = 0x3 << TB_BCAST_TYPE_SHIFT,
-
- // Unused bits 14-15
-};
-}
-#endif // LLVM_SUPPORT_X86FOLDTABLESUTILS_H
\ No newline at end of file
diff --git a/llvm/lib/Target/X86/X86InstrFoldTables.h b/llvm/lib/Target/X86/X86InstrFoldTables.h
index 384369b9560ac..b7aca27ab2bb5 100644
--- a/llvm/lib/Target/X86/X86InstrFoldTables.h
+++ b/llvm/lib/Target/X86/X86InstrFoldTables.h
@@ -14,10 +14,55 @@
#define LLVM_LIB_TARGET_X86_X86INSTRFOLDTABLES_H
#include <cstdint>
-#include "llvm/Support/X86FoldTablesUtils.h"
namespace llvm {
+enum {
+ // Select which memory operand is being unfolded.
+ // (stored in bits 0 - 2)
+ TB_INDEX_0 = 0,
+ TB_INDEX_1 = 1,
+ TB_INDEX_2 = 2,
+ TB_INDEX_3 = 3,
+ TB_INDEX_4 = 4,
+ TB_INDEX_MASK = 0x7,
+
+ // Do not insert the reverse map (MemOp -> RegOp) into the table.
+ // This may be needed because there is a many -> one mapping.
+ TB_NO_REVERSE = 1 << 3,
+
+ // Do not insert the forward map (RegOp -> MemOp) into the table.
+ // This is needed for Native Client, which prohibits branch
+ // instructions from using a memory operand.
+ TB_NO_FORWARD = 1 << 4,
+
+ TB_FOLDED_LOAD = 1 << 5,
+ TB_FOLDED_STORE = 1 << 6,
+ TB_FOLDED_BCAST = 1 << 7,
+
+ // Minimum alignment required for load/store.
+ // Used for RegOp->MemOp conversion. Encoded as Log2(Align) + 1 to allow 0
+ // to mean align of 0.
+ // (stored in bits 8 - 11)
+ TB_ALIGN_SHIFT = 8,
+ TB_ALIGN_NONE = 0 << TB_ALIGN_SHIFT,
+ TB_ALIGN_16 = 5 << TB_ALIGN_SHIFT,
+ TB_ALIGN_32 = 6 << TB_ALIGN_SHIFT,
+ TB_ALIGN_64 = 7 << TB_ALIGN_SHIFT,
+ TB_ALIGN_MASK = 0xf << TB_ALIGN_SHIFT,
+
+ // Broadcast type.
+ // (stored in bits 12 - 13)
+ TB_BCAST_TYPE_SHIFT = 12,
+ TB_BCAST_D = 0 << TB_BCAST_TYPE_SHIFT,
+ TB_BCAST_Q = 1 << TB_BCAST_TYPE_SHIFT,
+ TB_BCAST_SS = 2 << TB_BCAST_TYPE_SHIFT,
+ TB_BCAST_SD = 3 << TB_BCAST_TYPE_SHIFT,
+ TB_BCAST_MASK = 0x3 << TB_BCAST_TYPE_SHIFT,
+
+ // Unused bits 14-15
+};
+
// This struct is used for both the folding and unfold tables. They KeyOp
// is used to determine the sorting order.
struct X86MemoryFoldTableEntry {
diff --git a/llvm/test/TableGen/x86-auto-memfold.td b/llvm/test/TableGen/x86-auto-memfold.td
deleted file mode 100644
index bb2c124724d64..0000000000000
--- a/llvm/test/TableGen/x86-auto-memfold.td
+++ /dev/null
@@ -1,2 +0,0 @@
-// RUN: llvm-tblgen -gen-x86-fold-tables -asmwriternum=1 %p/../../lib/Target/X86/X86.td -I %p/../../include -I %p/../../lib/Target/X86/ -I %p/../../include/ -I %p/../../lib/Target/ --write-if-changed -o %t1
-// RUN: cmp --ignore-initial=0:568 %p/../../lib/Target/X86/X86MemFoldTables.inc %t1
diff --git a/llvm/utils/TableGen/X86FoldTablesEmitter.cpp b/llvm/utils/TableGen/X86FoldTablesEmitter.cpp
index ca4ac073b8d54..d4b2d06d8b999 100644
--- a/llvm/utils/TableGen/X86FoldTablesEmitter.cpp
+++ b/llvm/utils/TableGen/X86FoldTablesEmitter.cpp
@@ -15,9 +15,7 @@
#include "CodeGenTarget.h"
#include "TableGenBackends.h"
#include "X86RecognizableInstr.h"
-#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/FormattedStream.h"
-#include "llvm/Support/X86FoldTablesUtils.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/TableGenBackend.h"
@@ -25,14 +23,23 @@ using namespace llvm;
using namespace X86Disassembler;
namespace {
+
+// 3 possible strategies for the unfolding flag (TB_NO_REVERSE) of the
+// manual added entries.
+enum UnfoldStrategy {
+ UNFOLD, // Allow unfolding
+ NO_UNFOLD, // Prevent unfolding
+ NO_STRATEGY // Make decision according to operands' sizes
+};
+
// Represents an entry in the manual mapped instructions set.
struct ManualMapEntry {
const char *RegInstStr;
const char *MemInstStr;
- uint16_t Strategy;
+ UnfoldStrategy Strategy;
ManualMapEntry(const char *RegInstStr, const char *MemInstStr,
- uint16_t Strategy = 0)
+ UnfoldStrategy Strategy = NO_STRATEGY)
: RegInstStr(RegInstStr), MemInstStr(MemInstStr), Strategy(Strategy) {}
};
@@ -45,7 +52,37 @@ const char *ExplicitUnalign[] = {"MOVDQU", "MOVUPS", "MOVUPD",
"PCMPESTRM", "PCMPESTRI",
"PCMPISTRM", "PCMPISTRI" };
-#include "X86FoldTablesEmitterManualMapSet.inc"
+// For manually mapping instructions that do not match by their encoding.
+const ManualMapEntry ManualMapSet[] = {
+ { "ADD16ri_DB", "ADD16mi", NO_UNFOLD },
+ { "ADD16ri8_DB", "ADD16mi8", NO_UNFOLD },
+ { "ADD16rr_DB", "ADD16mr", NO_UNFOLD },
+ { "ADD32ri_DB", "ADD32mi", NO_UNFOLD },
+ { "ADD32ri8_DB", "ADD32mi8", NO_UNFOLD },
+ { "ADD32rr_DB", "ADD32mr", NO_UNFOLD },
+ { "ADD64ri32_DB", "ADD64mi32", NO_UNFOLD },
+ { "ADD64ri8_DB", "ADD64mi8", NO_UNFOLD },
+ { "ADD64rr_DB", "ADD64mr", NO_UNFOLD },
+ { "ADD8ri_DB", "ADD8mi", NO_UNFOLD },
+ { "ADD8rr_DB", "ADD8mr", NO_UNFOLD },
+ { "ADD16rr_DB", "ADD16rm", NO_UNFOLD },
+ { "ADD32rr_DB", "ADD32rm", NO_UNFOLD },
+ { "ADD64rr_DB", "ADD64rm", NO_UNFOLD },
+ { "ADD8rr_DB", "ADD8rm", NO_UNFOLD },
+ { "MMX_MOVD64from64rr", "MMX_MOVQ64mr", UNFOLD },
+ { "MMX_MOVD64grr", "MMX_MOVD64mr", UNFOLD },
+ { "MOVLHPSrr", "MOVHPSrm", NO_UNFOLD },
+ { "PUSH16r", "PUSH16rmm", UNFOLD },
+ { "PUSH32r", "PUSH32rmm", UNFOLD },
+ { "PUSH64r", "PUSH64rmm", UNFOLD },
+ { "TAILJMPr", "TAILJMPm", UNFOLD },
+ { "TAILJMPr64", "TAILJMPm64", UNFOLD },
+ { "TAILJMPr64_REX", "TAILJMPm64_REX", UNFOLD },
+ { "VMOVLHPSZrr", "VMOVHPSZ128rm", NO_UNFOLD },
+ { "VMOVLHPSrr", "VMOVHPSrm", NO_UNFOLD },
+};
+
+
static bool isExplicitAlign(const CodeGenInstruction *Inst) {
return any_of(ExplicitAlign, [Inst](const char *InstStr) {
return Inst->TheDef->getName().contains(InstStr);
@@ -69,63 +106,50 @@ class X86FoldTablesEmitter {
public:
bool CannotUnfold = false;
- bool CannotFold = false;
bool IsLoad = false;
bool IsStore = false;
bool IsAligned = false;
unsigned int Alignment = 0;
- X86FoldTableEntry() = default;
X86FoldTableEntry(const CodeGenInstruction *RegInst,
const CodeGenInstruction *MemInst)
: RegInst(RegInst), MemInst(MemInst) {}
void print(formatted_raw_ostream &OS) const {
- // Stop printing record if it can't fold and unfold.
- if(CannotUnfold && CannotFold)
- return;
OS.indent(2);
- OS << "{X86::" << RegInst->TheDef->getName() << ", ";
- OS << "X86::" << MemInst->TheDef->getName() << ", ";
+ OS << "{ X86::" << RegInst->TheDef->getName() << ",";
+ OS.PadToColumn(40);
+ OS << "X86::" << MemInst->TheDef->getName() << ",";
+ OS.PadToColumn(75);
std::string Attrs;
if (IsLoad)
- Attrs += "TB_FOLDED_LOAD|";
+ Attrs += "TB_FOLDED_LOAD | ";
if (IsStore)
- Attrs += "TB_FOLDED_STORE|";
+ Attrs += "TB_FOLDED_STORE | ";
if (CannotUnfold)
- Attrs += "TB_NO_REVERSE|";
- if (CannotFold)
- Attrs += "TB_NO_FORWARD|";
+ Attrs += "TB_NO_REVERSE | ";
if (IsAligned)
- Attrs += "TB_ALIGN_" + std::to_string(Alignment) + "|";
+ Attrs += "TB_ALIGN_" + std::to_string(Alignment) + " | ";
- StringRef SimplifiedAttrs = StringRef(Attrs).rtrim("|");
+ StringRef SimplifiedAttrs = StringRef(Attrs).rtrim("| ");
if (SimplifiedAttrs.empty())
SimplifiedAttrs = "0";
- OS << SimplifiedAttrs << "},\n";
+ OS << SimplifiedAttrs << " },\n";
}
- };
-
- struct CodeGenInstructionComparator {
- // Comparator function
- bool operator()(const CodeGenInstruction *LHS,
- const CodeGenInstruction *RHS) const {
- assert(LHS && RHS && "LHS and RHS shouldn't be nullptr");
- bool LHSpseudo = LHS->TheDef->getValueAsBit("isPseudo");
- bool RHSpseudo = RHS->TheDef->getValueAsBit("isPseudo");
+ bool operator<(const X86FoldTableEntry &RHS) const {
+ bool LHSpseudo = RegInst->TheDef->getValueAsBit("isPseudo");
+ bool RHSpseudo = RHS.RegInst->TheDef->getValueAsBit("isPseudo");
if (LHSpseudo != RHSpseudo)
return LHSpseudo;
- return LHS->TheDef->getName() < RHS->TheDef->getName();
+ return RegInst->TheDef->getName() < RHS.RegInst->TheDef->getName();
}
};
- typedef std::map<const CodeGenInstruction *, X86FoldTableEntry,
- CodeGenInstructionComparator>
- FoldTable;
+ typedef std::vector<X86FoldTableEntry> FoldTable;
// std::vector for each folding table.
// Table2Addr - Holds instructions which their memory form performs load+store
// Table#i - Holds instructions which the their memory form perform a load OR
@@ -147,14 +171,14 @@ class X86FoldTablesEmitter {
// Decides to which table to add the entry with the given instructions.
// S sets the strategy of adding the TB_NO_REVERSE flag.
void updateTables(const CodeGenInstruction *RegInstr,
- const CodeGenInstruction *MemInstr, const uint16_t S = 0,
- bool IsManual = false);
+ const CodeGenInstruction *MemInstr,
+ const UnfoldStrategy S = NO_STRATEGY);
// Generates X86FoldTableEntry with the given instructions and fill it with
// the appropriate flags - then adds it to Table.
void addEntryWithFlags(FoldTable &Table, const CodeGenInstruction *RegInstr,
- const CodeGenInstruction *MemInstr, const uint16_t S,
- const unsigned int FoldedInd, bool isManual);
+ const CodeGenInstruction *MemInstr,
+ const UnfoldStrategy S, const unsigned int FoldedInd);
// Print the given table as a static const C++ array of type
// X86MemoryFoldTableEntry.
@@ -163,8 +187,8 @@ class X86FoldTablesEmitter {
OS << "static const X86MemoryFoldTableEntry MemoryFold" << TableName
<< "[] = {\n";
- for (auto &E : Table)
- E.second.print(OS);
+ for (const X86FoldTableEntry &E : Table)
+ E.print(OS);
OS << "};\n\n";
}
@@ -369,25 +393,13 @@ class IsMatch {
void X86FoldTablesEmitter::addEntryWithFlags(FoldTable &Table,
const CodeGenInstruction *RegInstr,
const CodeGenInstruction *MemInstr,
- const uint16_t S,
- const unsigned int FoldedInd,
- bool isManual) {
+ const UnfoldStrategy S,
+ const unsigned int FoldedInd) {
X86FoldTableEntry Result = X86FoldTableEntry(RegInstr, MemInstr);
Record *RegRec = RegInstr->TheDef;
Record *MemRec = MemInstr->TheDef;
- if (isManual) {
- Result.CannotUnfold = (S & TB_NO_REVERSE) != 0;
- Result.CannotFold = (S & TB_NO_FORWARD) != 0;
- Result.IsLoad = (S & TB_FOLDED_LOAD) != 0;
- Result.IsStore = (S & TB_FOLDED_STORE) != 0;
- Result.IsAligned = (S & TB_ALIGN_MASK) != 0;
- Result.Alignment = 1 << (((S & TB_ALIGN_MASK) >> TB_ALIGN_SHIFT) - 1);
- Table[RegInstr] = Result;
- return;
- }
-
// Only table0 entries should explicitly specify a load or store flag.
if (&Table == &Table0) {
unsigned MemInOpsNum = MemRec->getValueAsDag("InOperandList")->getNumArgs();
@@ -410,27 +422,12 @@ void X86FoldTablesEmitter::addEntryWithFlags(FoldTable &Table,
// the register in the register form instruction.
// If the register's size is greater than the memory's operand size, do not
// allow unfolding.
-
- // the unfolded load size will be based on the register size. If that’s bigger
- // than the memory operand size, the unfolded load will load more memory and
- // potentially cause a memory fault.
- if (getRegOperandSize(RegOpRec) > getMemOperandSize(MemOpRec))
- Result.CannotUnfold = true;
-
- // Check no-kz version's isMoveReg
- Record *BaseDef = nullptr;
- if (RegRec->getName().ends_with("rkz") &&
- (BaseDef = Records.getDef(
- RegRec->getName().substr(0, RegRec->getName().size() - 2)))) {
- Result.CannotUnfold =
- Target.getInstruction(BaseDef).isMoveReg ? true : Result.CannotUnfold;
- } else if (RegRec->getName().ends_with("rk") &&
- (BaseDef = Records.getDef(
- RegRec->getName().substr(0, RegRec->getName().size() - 1)))) {
- Result.CannotUnfold =
- Target.getInstruction(BaseDef).isMoveReg ? true : Result.CannotUnfold;
- } else if (RegInstr->isMoveReg && Result.IsStore)
+ if (S == UNFOLD)
+ Result.CannotUnfold = false;
+ else if (S == NO_UNFOLD)
Result.CannotUnfold = true;
+ else if (getRegOperandSize(RegOpRec) > getMemOperandSize(MemOpRec))
+ Result.CannotUnfold = true; // S == NO_STRATEGY
uint64_t Enc = getValueFromBitsInit(RegRec->getValueAsBitsInit("OpEncBits"));
if (isExplicitAlign(RegInstr)) {
@@ -448,19 +445,13 @@ void X86FoldTablesEmitter::addEntryWithFlags(FoldTable &Table,
Result.Alignment = 16;
}
}
- // Expand is only ever created as a masked instruction. It is not safe to
- // unfold a masked expand because we don't know if it came from an expand load
- // intrinsic or folding a plain load. If it is from a expand load intrinsic,
- // Unfolding to plain load would read more elements and could trigger a fault.
- if (RegRec->getName().contains("EXPAND"))
- Result.CannotUnfold = true;
- Table[RegInstr] = Result;
+ Table.push_back(Result);
}
void X86FoldTablesEmitter::updateTables(const CodeGenInstruction *RegInstr,
const CodeGenInstruction *MemInstr,
- const uint16_t S, bool IsManual) {
+ const UnfoldStrategy S) {
Record *RegRec = RegInstr->TheDef;
Record *MemRec = MemInstr->TheDef;
@@ -471,7 +462,7 @@ void X86FoldTablesEmitter::updateTables(const CodeGenInstruction *RegInstr,
// Instructions which Read-Modify-Write should be added to Table2Addr.
if (MemOutSize != RegOutSize && MemInSize == RegInSize) {
- addEntryWithFlags(Table2Addr, RegInstr, MemInstr, S, 0, IsManual);
+ addEntryWithFlags(Table2Addr, RegInstr, MemInstr, S, 0);
return;
}
@@ -488,19 +479,19 @@ void X86FoldTablesEmitter::updateTables(const CodeGenInstruction *RegInstr,
isMemoryOperand(MemOpRec)) {
switch (i) {
case 0:
- addEntryWithFlags(Table0, RegInstr, MemInstr, S, 0, IsManual);
+ addEntryWithFlags(Table0, RegInstr, MemInstr, S, 0);
return;
case 1:
- addEntryWithFlags(Table1, RegInstr, MemInstr, S, 1, IsManual);
+ addEntryWithFlags(Table1, RegInstr, MemInstr, S, 1);
return;
case 2:
- addEntryWithFlags(Table2, RegInstr, MemInstr, S, 2, IsManual);
+ addEntryWithFlags(Table2, RegInstr, MemInstr, S, 2);
return;
case 3:
- addEntryWithFlags(Table3, RegInstr, MemInstr, S, 3, IsManual);
+ addEntryWithFlags(Table3, RegInstr, MemInstr, S, 3);
return;
case 4:
- addEntryWithFlags(Table4, RegInstr, MemInstr, S, 4, IsManual);
+ addEntryWithFlags(Table4, RegInstr, MemInstr, S, 4);
return;
}
}
@@ -517,7 +508,7 @@ void X86FoldTablesEmitter::updateTables(const CodeGenInstruction *RegInstr,
Record *MemOpRec = MemInstr->Operands[RegOutSize - 1].Rec;
if (isRegisterOperand(RegOpRec) && isMemoryOperand(MemOpRec) &&
getRegOperandSize(RegOpRec) == getMemOperandSize(MemOpRec))
- addEntryWithFlags(Table0, RegInstr, MemInstr, S, 0, IsManual);
+ addEntryWithFlags(Table0, RegInstr, MemInstr, S, 0);
}
}
@@ -600,9 +591,17 @@ void X86FoldTablesEmitter::run(formatted_raw_ostream &OS) {
Record *MemInstIter = Records.getDef(Entry.MemInstStr);
updateTables(&(Target.getInstruction(RegInstIter)),
- &(Target.getInstruction(MemInstIter)), Entry.Strategy, true);
+ &(Target.getInstruction(MemInstIter)), Entry.Strategy);
}
+ // Sort the tables before printing.
+ llvm::sort(Table2Addr);
+ llvm::sort(Table0);
+ llvm::sort(Table1);
+ llvm::sort(Table2);
+ llvm::sort(Table3);
+ llvm::sort(Table4);
+
// Print all tables.
printTable(Table2Addr, "Table2Addr", OS);
printTable(Table0, "Table0", OS);
diff --git a/llvm/utils/TableGen/X86FoldTablesEmitterManualMapSet.inc b/llvm/utils/TableGen/X86FoldTablesEmitterManualMapSet.inc
deleted file mode 100644
index 8b7f3878f6f59..0000000000000
--- a/llvm/utils/TableGen/X86FoldTablesEmitterManualMapSet.inc
+++ /dev/null
@@ -1,83 +0,0 @@
-const ManualMapEntry ManualMapSet[] = {
- // Part1: These following records are for manually mapping instructions that
- // do not match by their encoding.
- { "ADD16ri_DB", "ADD16mi", TB_NO_REVERSE },
- { "ADD16ri8_DB", "ADD16mi8", TB_NO_REVERSE },
- { "ADD16rr_DB", "ADD16mr", TB_NO_REVERSE },
- { "ADD32ri_DB", "ADD32mi", TB_NO_REVERSE },
- { "ADD32ri8_DB", "ADD32mi8", TB_NO_REVERSE },
- { "ADD32rr_DB", "ADD32mr", TB_NO_REVERSE },
- { "ADD64ri32_DB", "ADD64mi32", TB_NO_REVERSE },
- { "ADD64ri8_DB", "ADD64mi8", TB_NO_REVERSE },
- { "ADD64rr_DB", "ADD64mr", TB_NO_REVERSE },
- { "ADD8ri_DB", "ADD8mi", TB_NO_REVERSE },
- { "ADD8rr_DB", "ADD8mr", TB_NO_REVERSE },
- { "ADD16rr_DB", "ADD16rm", TB_NO_REVERSE },
- { "ADD32rr_DB", "ADD32rm", TB_NO_REVERSE },
- { "ADD64rr_DB", "ADD64rm", TB_NO_REVERSE },
- { "ADD8rr_DB", "ADD8rm", TB_NO_REVERSE },
- { "MMX_MOVD64from64rr", "MMX_MOVQ64mr", TB_FOLDED_STORE },
- { "MMX_MOVD64grr", "MMX_MOVD64mr", TB_FOLDED_STORE },
- { "MOV64toSDrr", "MOV64mr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "MOVDI2SSrr", "MOV32mr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "MOVPQIto64rr", "MOVPQI2QImr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "MOVSDto64rr", "MOVSDmr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "MOVSS2DIrr", "MOVSSmr", TB_FOLDED_STORE },
- { "MOVLHPSrr", "MOVHPSrm", TB_NO_REVERSE },
- { "PUSH16r", "PUSH16rmm", TB_FOLDED_LOAD },
- { "PUSH32r", "PUSH32rmm", TB_FOLDED_LOAD },
- { "PUSH64r", "PUSH64rmm", TB_FOLDED_LOAD },
- { "TAILJMPr", "TAILJMPm", TB_FOLDED_LOAD },
- { "TAILJMPr64", "TAILJMPm64", TB_FOLDED_LOAD },
- { "TAILJMPr64_REX", "TAILJMPm64_REX", TB_FOLDED_LOAD },
- { "TCRETURNri", "TCRETURNmi", TB_FOLDED_LOAD | TB_NO_FORWARD },
- { "TCRETURNri64", "TCRETURNmi64", TB_FOLDED_LOAD | TB_NO_FORWARD },
- { "VMOVLHPSZrr", "VMOVHPSZ128rm", TB_NO_REVERSE },
- { "VMOVLHPSrr", "VMOVHPSrm", TB_NO_REVERSE },
- { "VMOV64toSDZrr", "MOV64mr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOV64toSDrr", "MOV64mr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVDI2SSZrr", "MOV32mr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVDI2SSrr", "MOV32mr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVPQIto64Zrr", "VMOVPQI2QIZmr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVPQIto64rr", "VMOVPQI2QImr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVSDto64Zrr", "VMOVSDZmr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVSDto64rr", "VMOVSDmr", TB_FOLDED_STORE | TB_NO_REVERSE },
- { "VMOVSS2DIZrr", "VMOVSSZmr", TB_FOLDED_STORE },
- { "VMOVSS2DIrr", "VMOVSSmr", TB_FOLDED_STORE },
- { "MMX_MOVD64to64rr", "MMX_MOVQ64rm", 0 },
- { "MOV64toPQIrr", "MOVQI2PQIrm", TB_NO_REVERSE },
- { "MOV64toSDrr", "MOVSDrm_alt", TB_NO_REVERSE },
- { "MOVDI2SSrr", "MOVSSrm_alt", 0 },
- { "VMOV64toPQIZrr", "VMOVQI2PQIZrm", TB_NO_REVERSE },
- { "VMOV64toPQIrr", "VMOVQI2PQIrm", TB_NO_REVERSE },
- { "VMOV64toSDZrr", "VMOVSDZrm_alt", TB_NO_REVERSE },
- { "VMOV64toSDrr", "VMOVSDrm_alt", TB_NO_REVERSE },
- { "VMOVDI2SSZrr", "VMOVSSZrm_alt", 0 },
- { "VMOVDI2SSrr", "VMOVSSrm_alt", 0 },
- { "MOVSDrr", "MOVLPDrm", TB_NO_REVERSE },
- { "VMOVSDZrr", "VMOVLPDZ128rm", TB_NO_REVERSE },
- { "VMOVSDrr", "VMOVLPDrm", TB_NO_REVERSE },
-
- // Part2: These following records are for manually mapping instructions that
- // have same opcode.
- // INSERTPSrm has no count_s while INSERTPSrr has count_s.
- // count_s is to indicate which element in dst vector is inserted.
- // if count_s!=0, we can't fold INSERTPSrr into INSERTPSrm
- //
- // the following folding can happen when count_s==0
- // load xmm0, m32
- // insertpsrr xmm1, xmm0, imm
- // =>
- // insertpsrm xmm1, m32, imm
- { "INSERTPSrr", "INSERTPSrm", TB_NO_REVERSE | TB_NO_FORWARD },
- { "UD1Lr", "UD1Lm", TB_NO_REVERSE | TB_NO_FORWARD },
- { "UD1Qr", "UD1Qm", TB_NO_REVERSE | TB_NO_FORWARD },
- { "UD1Wr", "UD1Wm", TB_NO_REVERSE | TB_NO_FORWARD },
- // Remove {"MMX_MOVQ64rr", "MMX_MOVQ64mr"} since it will create duplicate in
- // unfolding table due to the {"MMX_MOVD64from64rr", "MMX_MOVQ64mr"}
- { "MMX_MOVQ64rr", "MMX_MOVQ64mr", TB_NO_FORWARD | TB_NO_REVERSE },
- // Remove {"MMX_MOVQ64rr", "MMX_MOVQ64rm"} since it will create duplicate in
- // unfolding table due to the {"MMX_MOVD64from64rr", "MMX_MOVQ64rm"}
- { "MMX_MOVQ64rr", "MMX_MOVQ64rm", TB_NO_FORWARD | TB_NO_REVERSE },
-};
-
More information about the llvm-commits
mailing list