6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-29 13:24:25 +00:00
Code Issues Projects Releases Wiki Activity

Tablegen generated code already tests the opcode value, so it's not

Browse Source 
necessary to use dyn_cast in these predicates.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@55055 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman
2008-08-20 15:24:22 +00:00
parent c53ec49885
commit 67ca6be16a
4 changed files with 183 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/Target/Alpha/AlphaInstrInfo.td
View File

@ -89,11 +89,9 @@ def immSExt16int : PatLeaf<(imm), [{ //(int)imm fits in a 16 bit sign extended
}], SExt16>; }], SExt16>;
def zappat : PatFrag<(ops node:$LHS), (and node:$LHS, imm:$L), [{ def zappat : PatFrag<(ops node:$LHS), (and node:$LHS, imm:$L), [{
if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N->getOperand(1))) { ConstantSDNode *RHS = cast<ConstantSDNode>(N->getOperand(1));
uint64_t build = get_zapImm(N->getOperand(0), (uint64_t)RHS->getValue()); uint64_t build = get_zapImm(N->getOperand(0), (uint64_t)RHS->getValue());
return build != 0; return build != 0;
}
return false;
}]>; }]>;
def immFPZ : PatLeaf<(fpimm), [{ //the only fpconstant nodes are +/- 0.0 def immFPZ : PatLeaf<(fpimm), [{ //the only fpconstant nodes are +/- 0.0

352
lib/Target/TargetSelectionDAG.td
View File

@ -497,347 +497,291 @@ def ineg : PatFrag<(ops node:$in), (sub 0, node:$in)>;
// load fragments. // load fragments.
def load : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def load : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::NON_EXTLOAD && return LD->getExtensionType() == ISD::NON_EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED; LD->getAddressingMode() == ISD::UNINDEXED;
return false;
}]>; }]>;
// extending load fragments. // extending load fragments.
def extloadi1 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def extloadi1 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::EXTLOAD && return LD->getExtensionType() == ISD::EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i1; LD->getMemoryVT() == MVT::i1;
return false;
}]>; }]>;
def extloadi8 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def extloadi8 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::EXTLOAD && return LD->getExtensionType() == ISD::EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i8; LD->getMemoryVT() == MVT::i8;
return false;
}]>; }]>;
def extloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def extloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::EXTLOAD && return LD->getExtensionType() == ISD::EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i16; LD->getMemoryVT() == MVT::i16;
return false;
}]>; }]>;
def extloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def extloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::EXTLOAD && return LD->getExtensionType() == ISD::EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i32; LD->getMemoryVT() == MVT::i32;
return false;
}]>; }]>;
def extloadf32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def extloadf32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::EXTLOAD && return LD->getExtensionType() == ISD::EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::f32; LD->getMemoryVT() == MVT::f32;
return false;
}]>; }]>;
def extloadf64 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def extloadf64 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::EXTLOAD && return LD->getExtensionType() == ISD::EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::f64; LD->getMemoryVT() == MVT::f64;
return false;
}]>; }]>;
def sextloadi1 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def sextloadi1 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::SEXTLOAD && return LD->getExtensionType() == ISD::SEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i1; LD->getMemoryVT() == MVT::i1;
return false;
}]>; }]>;
def sextloadi8 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def sextloadi8 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::SEXTLOAD && return LD->getExtensionType() == ISD::SEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i8; LD->getMemoryVT() == MVT::i8;
return false;
}]>; }]>;
def sextloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def sextloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::SEXTLOAD && return LD->getExtensionType() == ISD::SEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i16; LD->getMemoryVT() == MVT::i16;
return false;
}]>; }]>;
def sextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def sextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::SEXTLOAD && return LD->getExtensionType() == ISD::SEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i32; LD->getMemoryVT() == MVT::i32;
return false;
}]>; }]>;
def zextloadi1 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def zextloadi1 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::ZEXTLOAD && return LD->getExtensionType() == ISD::ZEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i1; LD->getMemoryVT() == MVT::i1;
return false;
}]>; }]>;
def zextloadi8 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def zextloadi8 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::ZEXTLOAD && return LD->getExtensionType() == ISD::ZEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i8; LD->getMemoryVT() == MVT::i8;
return false;
}]>; }]>;
def zextloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def zextloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::ZEXTLOAD && return LD->getExtensionType() == ISD::ZEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i16; LD->getMemoryVT() == MVT::i16;
return false;
}]>; }]>;
def zextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def zextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::ZEXTLOAD && return LD->getExtensionType() == ISD::ZEXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getMemoryVT() == MVT::i32; LD->getMemoryVT() == MVT::i32;
return false;
}]>; }]>;
// store fragments. // store fragments.
def store : PatFrag<(ops node:$val, node:$ptr), def store : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return !ST->isTruncatingStore() && return !ST->isTruncatingStore() &&
ST->getAddressingMode() == ISD::UNINDEXED; ST->getAddressingMode() == ISD::UNINDEXED;
return false;
}]>; }]>;
// truncstore fragments. // truncstore fragments.
def truncstorei8 : PatFrag<(ops node:$val, node:$ptr), def truncstorei8 : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i8 && return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i8 &&
ST->getAddressingMode() == ISD::UNINDEXED; ST->getAddressingMode() == ISD::UNINDEXED;
return false;
}]>; }]>;
def truncstorei16 : PatFrag<(ops node:$val, node:$ptr), def truncstorei16 : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i16 && return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i16 &&
ST->getAddressingMode() == ISD::UNINDEXED; ST->getAddressingMode() == ISD::UNINDEXED;
return false;
}]>; }]>;
def truncstorei32 : PatFrag<(ops node:$val, node:$ptr), def truncstorei32 : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i32 && return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i32 &&
ST->getAddressingMode() == ISD::UNINDEXED; ST->getAddressingMode() == ISD::UNINDEXED;
return false; return false;
}]>; }]>;
def truncstoref32 : PatFrag<(ops node:$val, node:$ptr), def truncstoref32 : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f32 && return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f32 &&
ST->getAddressingMode() == ISD::UNINDEXED; ST->getAddressingMode() == ISD::UNINDEXED;
return false;
}]>; }]>;
def truncstoref64 : PatFrag<(ops node:$val, node:$ptr), def truncstoref64 : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f64 && return ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f64 &&
ST->getAddressingMode() == ISD::UNINDEXED; ST->getAddressingMode() == ISD::UNINDEXED;
return false;
}]>; }]>;
// indexed store fragments. // indexed store fragments.
def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset), def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) && return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
!ST->isTruncatingStore(); !ST->isTruncatingStore();
}
return false;
}]>; }]>;
def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset), def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) && return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i1; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i1;
}
return false;
}]>; }]>;
def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset), def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) && return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i8; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i8;
}
return false;
}]>; }]>;
def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset), def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) && return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i16; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i16;
}
return false;
}]>; }]>;
def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset), def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) && return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i32; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i32;
}
return false;
}]>; }]>;
def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset), def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) && return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f32; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f32;
}
return false;
}]>; }]>;
def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset), def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
(ist node:$val, node:$ptr, node:$offset), [{ (ist node:$val, node:$ptr, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return !ST->isTruncatingStore() && return !ST->isTruncatingStore() &&
(AM == ISD::POST_INC || AM == ISD::POST_DEC); (AM == ISD::POST_INC || AM == ISD::POST_DEC);
}
return false;
}]>; }]>;
def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset), def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::POST_INC || AM == ISD::POST_DEC) && return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i1; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i1;
}
return false;
}]>; }]>;
def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset), def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::POST_INC || AM == ISD::POST_DEC) && return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i8; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i8;
}
return false;
}]>; }]>;
def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset), def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::POST_INC || AM == ISD::POST_DEC) && return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i16; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i16;
}
return false;
}]>; }]>;
def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset), def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::POST_INC || AM == ISD::POST_DEC) && return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i32; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::i32;
}
return false;
}]>; }]>;
def post_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset), def post_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
(ist node:$val, node:$base, node:$offset), [{ (ist node:$val, node:$base, node:$offset), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) { StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
return (AM == ISD::POST_INC || AM == ISD::POST_DEC) && return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f32; ST->isTruncatingStore() && ST->getMemoryVT() == MVT::f32;
}
return false;
}]>; }]>;
//Atomic patterns // Atomic patterns
def atomic_cmp_swap_8 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp), def atomic_cmp_swap_8 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp),
(atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{ (atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i8; return V->getValueType(0) == MVT::i8;
return false;
}]>; }]>;
def atomic_cmp_swap_16 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp), def atomic_cmp_swap_16 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp),
(atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{ (atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i16; return V->getValueType(0) == MVT::i16;
return false;
}]>; }]>;
def atomic_cmp_swap_32 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp), def atomic_cmp_swap_32 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp),
(atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{ (atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i32; return V->getValueType(0) == MVT::i32;
return false;
}]>; }]>;
def atomic_cmp_swap_64 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp), def atomic_cmp_swap_64 : PatFrag<(ops node:$ptr, node:$cmp, node:$swp),
(atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{ (atomic_cmp_swap node:$ptr, node:$cmp, node:$swp), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i64; return V->getValueType(0) == MVT::i64;
return false;
}]>; }]>;
def atomic_load_add_8 : PatFrag<(ops node:$ptr, node:$inc), def atomic_load_add_8 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_load_add node:$ptr, node:$inc), [{ (atomic_load_add node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i8; return V->getValueType(0) == MVT::i8;
return false;
}]>; }]>;
def atomic_load_add_16 : PatFrag<(ops node:$ptr, node:$inc), def atomic_load_add_16 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_load_add node:$ptr, node:$inc), [{ (atomic_load_add node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i16; return V->getValueType(0) == MVT::i16;
return false;
}]>; }]>;
def atomic_load_add_32 : PatFrag<(ops node:$ptr, node:$inc), def atomic_load_add_32 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_load_add node:$ptr, node:$inc), [{ (atomic_load_add node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i32; return V->getValueType(0) == MVT::i32;
return false;
}]>; }]>;
def atomic_load_add_64 : PatFrag<(ops node:$ptr, node:$inc), def atomic_load_add_64 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_load_add node:$ptr, node:$inc), [{ (atomic_load_add node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i64; return V->getValueType(0) == MVT::i64;
return false;
}]>; }]>;
def atomic_swap_8 : PatFrag<(ops node:$ptr, node:$inc), def atomic_swap_8 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_swap node:$ptr, node:$inc), [{ (atomic_swap node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i8; return V->getValueType(0) == MVT::i8;
return false;
}]>; }]>;
def atomic_swap_16 : PatFrag<(ops node:$ptr, node:$inc), def atomic_swap_16 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_swap node:$ptr, node:$inc), [{ (atomic_swap node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i16; return V->getValueType(0) == MVT::i16;
return false;
}]>; }]>;
def atomic_swap_32 : PatFrag<(ops node:$ptr, node:$inc), def atomic_swap_32 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_swap node:$ptr, node:$inc), [{ (atomic_swap node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i32; return V->getValueType(0) == MVT::i32;
return false;
}]>; }]>;
def atomic_swap_64 : PatFrag<(ops node:$ptr, node:$inc), def atomic_swap_64 : PatFrag<(ops node:$ptr, node:$inc),
(atomic_swap node:$ptr, node:$inc), [{ (atomic_swap node:$ptr, node:$inc), [{
if (AtomicSDNode* V = dyn_cast<AtomicSDNode>(N)) AtomicSDNode* V = cast<AtomicSDNode>(N);
return V->getValueType(0) == MVT::i64; return V->getValueType(0) == MVT::i64;
return false;
}]>; }]>;

34
lib/Target/X86/X86InstrInfo.td
View File

@ -232,28 +232,26 @@ def i32immSExt8 : PatLeaf<(i32 imm), [{
// It's always safe to treat a anyext i16 load as a i32 load if the i16 is // It's always safe to treat a anyext i16 load as a i32 load if the i16 is
// known to be 32-bit aligned or better. Ditto for i8 to i16. // known to be 32-bit aligned or better. Ditto for i8 to i16.
def loadi16 : PatFrag<(ops node:$ptr), (i16 (ld node:$ptr)), [{ def loadi16 : PatFrag<(ops node:$ptr), (i16 (ld node:$ptr)), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) { LoadSDNode *LD = cast<LoadSDNode>(N);
if (LD->getAddressingMode() != ISD::UNINDEXED) if (LD->getAddressingMode() != ISD::UNINDEXED)
return false; return false;
ISD::LoadExtType ExtType = LD->getExtensionType(); ISD::LoadExtType ExtType = LD->getExtensionType();
if (ExtType == ISD::NON_EXTLOAD) if (ExtType == ISD::NON_EXTLOAD)
return true; return true;
if (ExtType == ISD::EXTLOAD) if (ExtType == ISD::EXTLOAD)
return LD->getAlignment() >= 2 && !LD->isVolatile(); return LD->getAlignment() >= 2 && !LD->isVolatile();
}
return false; return false;
}]>; }]>;
def loadi32 : PatFrag<(ops node:$ptr), (i32 (ld node:$ptr)), [{ def loadi32 : PatFrag<(ops node:$ptr), (i32 (ld node:$ptr)), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) { LoadSDNode *LD = cast<LoadSDNode>(N);
if (LD->getAddressingMode() != ISD::UNINDEXED) if (LD->getAddressingMode() != ISD::UNINDEXED)
return false; return false;
ISD::LoadExtType ExtType = LD->getExtensionType(); ISD::LoadExtType ExtType = LD->getExtensionType();
if (ExtType == ISD::NON_EXTLOAD) if (ExtType == ISD::NON_EXTLOAD)
return true; return true;
if (ExtType == ISD::EXTLOAD) if (ExtType == ISD::EXTLOAD)
return LD->getAlignment() >= 4 && !LD->isVolatile(); return LD->getAlignment() >= 4 && !LD->isVolatile();
}
return false; return false;
}]>; }]>;

36
lib/Target/X86/X86InstrSSE.td
View File

@ -99,20 +99,18 @@ def loadv2i64 : PatFrag<(ops node:$ptr), (v2i64 (load node:$ptr))>;
// Like 'store', but always requires vector alignment. // Like 'store', but always requires vector alignment.
def alignedstore : PatFrag<(ops node:$val, node:$ptr), def alignedstore : PatFrag<(ops node:$val, node:$ptr),
(st node:$val, node:$ptr), [{ (st node:$val, node:$ptr), [{
if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) StoreSDNode *ST = cast<StoreSDNode>(N);
return !ST->isTruncatingStore() && return !ST->isTruncatingStore() &&
ST->getAddressingMode() == ISD::UNINDEXED && ST->getAddressingMode() == ISD::UNINDEXED &&
ST->getAlignment() >= 16; ST->getAlignment() >= 16;
return false;
}]>; }]>;
// Like 'load', but always requires vector alignment. // Like 'load', but always requires vector alignment.
def alignedload : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def alignedload : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::NON_EXTLOAD && return LD->getExtensionType() == ISD::NON_EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getAlignment() >= 16; LD->getAlignment() >= 16;
return false;
}]>; }]>;
def alignedloadfsf32 : PatFrag<(ops node:$ptr), (f32 (alignedload node:$ptr))>; def alignedloadfsf32 : PatFrag<(ops node:$ptr), (f32 (alignedload node:$ptr))>;
@ -128,11 +126,10 @@ def alignedloadv2i64 : PatFrag<(ops node:$ptr), (v2i64 (alignedload node:$ptr))>
// FIXME: Actually implement support for targets that don't require the // FIXME: Actually implement support for targets that don't require the
// alignment. This probably wants a subtarget predicate. // alignment. This probably wants a subtarget predicate.
def memop : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def memop : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::NON_EXTLOAD && return LD->getExtensionType() == ISD::NON_EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getAlignment() >= 16; LD->getAlignment() >= 16;
return false;
}]>; }]>;
def memopfsf32 : PatFrag<(ops node:$ptr), (f32 (memop node:$ptr))>; def memopfsf32 : PatFrag<(ops node:$ptr), (f32 (memop node:$ptr))>;
@ -147,11 +144,10 @@ def memopv16i8 : PatFrag<(ops node:$ptr), (v16i8 (memop node:$ptr))>;
// 16-byte boundary. // 16-byte boundary.
// FIXME: 8 byte alignment for mmx reads is not required // FIXME: 8 byte alignment for mmx reads is not required
def memop64 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{ def memop64 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) LoadSDNode *LD = cast<LoadSDNode>(N);
return LD->getExtensionType() == ISD::NON_EXTLOAD && return LD->getExtensionType() == ISD::NON_EXTLOAD &&
LD->getAddressingMode() == ISD::UNINDEXED && LD->getAddressingMode() == ISD::UNINDEXED &&
LD->getAlignment() >= 8; LD->getAlignment() >= 8;
return false;
}]>; }]>;
def memopv8i8 : PatFrag<(ops node:$ptr), (v8i8 (memop64 node:$ptr))>; def memopv8i8 : PatFrag<(ops node:$ptr), (v8i8 (memop64 node:$ptr))>;