mirror of
https://github.com/RPCSX/llvm.git
synced 2024-12-12 06:06:19 +00:00
Fix up LoadExtActions, TruncStoreActions, and IndexedModeActions representation and setter and getter's so they will continue to work if the number of scalar ValueType's exceeds 31.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@103742 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng
parent
c9c4dacd03
commit
b21f5a5511
@ -385,35 +385,31 @@ public:
|
||||
/// either it is legal, needs to be promoted to a larger size, needs to be
|
||||
/// expanded to some other code sequence, or the target has a custom expander
|
||||
/// for it.
|
||||
LegalizeAction getLoadExtAction(unsigned LType, EVT VT) const {
|
||||
assert(LType < array_lengthof(LoadExtActions) &&
|
||||
(unsigned)VT.getSimpleVT().SimpleTy < sizeof(LoadExtActions[0])*4 &&
|
||||
LegalizeAction getLoadExtAction(unsigned ExtType, EVT VT) const {
|
||||
assert(ExtType < ISD::LAST_LOADEXT_TYPE &&
|
||||
(unsigned)VT.getSimpleVT().SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
"Table isn't big enough!");
|
||||
return (LegalizeAction)((LoadExtActions[LType] >>
|
||||
(2*VT.getSimpleVT().SimpleTy)) & 3);
|
||||
return (LegalizeAction)LoadExtActions[VT.getSimpleVT().SimpleTy][ExtType];
|
||||
}
|
||||
|
||||
/// isLoadExtLegal - Return true if the specified load with extension is legal
|
||||
/// on this target.
|
||||
bool isLoadExtLegal(unsigned LType, EVT VT) const {
|
||||
bool isLoadExtLegal(unsigned ExtType, EVT VT) const {
|
||||
return VT.isSimple() &&
|
||||
(getLoadExtAction(LType, VT) == Legal ||
|
||||
getLoadExtAction(LType, VT) == Custom);
|
||||
(getLoadExtAction(ExtType, VT) == Legal ||
|
||||
getLoadExtAction(ExtType, VT) == Custom);
|
||||
}
|
||||
|
||||
/// getTruncStoreAction - Return how this store with truncation should be
|
||||
/// treated: either it is legal, needs to be promoted to a larger size, needs
|
||||
/// to be expanded to some other code sequence, or the target has a custom
|
||||
/// expander for it.
|
||||
LegalizeAction getTruncStoreAction(EVT ValVT,
|
||||
EVT MemVT) const {
|
||||
assert((unsigned)ValVT.getSimpleVT().SimpleTy <
|
||||
array_lengthof(TruncStoreActions) &&
|
||||
(unsigned)MemVT.getSimpleVT().SimpleTy <
|
||||
sizeof(TruncStoreActions[0])*4 &&
|
||||
LegalizeAction getTruncStoreAction(EVT ValVT, EVT MemVT) const {
|
||||
assert((unsigned)ValVT.getSimpleVT().SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
(unsigned)MemVT.getSimpleVT().SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
"Table isn't big enough!");
|
||||
return (LegalizeAction)((TruncStoreActions[ValVT.getSimpleVT().SimpleTy] >>
|
||||
(2*MemVT.getSimpleVT().SimpleTy)) & 3);
|
||||
return (LegalizeAction)TruncStoreActions[ValVT.getSimpleVT().SimpleTy]
|
||||
[MemVT.getSimpleVT().SimpleTy];
|
||||
}
|
||||
|
||||
/// isTruncStoreLegal - Return true if the specified store with truncation is
|
||||
@ -430,11 +426,11 @@ public:
|
||||
/// for it.
|
||||
LegalizeAction
|
||||
getIndexedLoadAction(unsigned IdxMode, EVT VT) const {
|
||||
assert( IdxMode < array_lengthof(IndexedModeActions[0][0]) &&
|
||||
assert( IdxMode < ISD::LAST_INDEXED_MODE &&
|
||||
((unsigned)VT.getSimpleVT().SimpleTy) < MVT::LAST_VALUETYPE &&
|
||||
"Table isn't big enough!");
|
||||
return (LegalizeAction)((IndexedModeActions[
|
||||
(unsigned)VT.getSimpleVT().SimpleTy][0][IdxMode]));
|
||||
unsigned Ty = (unsigned)VT.getSimpleVT().SimpleTy;
|
||||
return (LegalizeAction)((IndexedModeActions[Ty][IdxMode] & 0xf0) >> 4);
|
||||
}
|
||||
|
||||
/// isIndexedLoadLegal - Return true if the specified indexed load is legal
|
||||
@ -451,11 +447,11 @@ public:
|
||||
/// for it.
|
||||
LegalizeAction
|
||||
getIndexedStoreAction(unsigned IdxMode, EVT VT) const {
|
||||
assert(IdxMode < array_lengthof(IndexedModeActions[0][1]) &&
|
||||
(unsigned)VT.getSimpleVT().SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
assert( IdxMode < ISD::LAST_INDEXED_MODE &&
|
||||
((unsigned)VT.getSimpleVT().SimpleTy) < MVT::LAST_VALUETYPE &&
|
||||
"Table isn't big enough!");
|
||||
return (LegalizeAction)((IndexedModeActions[
|
||||
(unsigned)VT.getSimpleVT().SimpleTy][1][IdxMode]));
|
||||
unsigned Ty = (unsigned)VT.getSimpleVT().SimpleTy;
|
||||
return (LegalizeAction)(IndexedModeActions[Ty][IdxMode] & 0x0f);
|
||||
}
|
||||
|
||||
/// isIndexedStoreLegal - Return true if the specified indexed load is legal
|
||||
@ -1000,23 +996,21 @@ protected:
|
||||
/// setLoadExtAction - Indicate that the specified load with extension does
|
||||
/// not work with the specified type and indicate what to do about it.
|
||||
void setLoadExtAction(unsigned ExtType, MVT VT,
|
||||
LegalizeAction Action) {
|
||||
assert((unsigned)VT.SimpleTy*2 < 63 &&
|
||||
ExtType < array_lengthof(LoadExtActions) &&
|
||||
LegalizeAction Action) {
|
||||
assert(ExtType < ISD::LAST_LOADEXT_TYPE &&
|
||||
(unsigned)VT.SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
"Table isn't big enough!");
|
||||
LoadExtActions[ExtType] &= ~(uint64_t(3UL) << VT.SimpleTy*2);
|
||||
LoadExtActions[ExtType] |= (uint64_t)Action << VT.SimpleTy*2;
|
||||
LoadExtActions[VT.SimpleTy][ExtType] = (uint8_t)Action;
|
||||
}
|
||||
|
||||
/// setTruncStoreAction - Indicate that the specified truncating store does
|
||||
/// not work with the specified type and indicate what to do about it.
|
||||
void setTruncStoreAction(MVT ValVT, MVT MemVT,
|
||||
LegalizeAction Action) {
|
||||
assert((unsigned)ValVT.SimpleTy < array_lengthof(TruncStoreActions) &&
|
||||
(unsigned)MemVT.SimpleTy*2 < 63 &&
|
||||
assert((unsigned)ValVT.SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
(unsigned)MemVT.SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
"Table isn't big enough!");
|
||||
TruncStoreActions[ValVT.SimpleTy] &= ~(uint64_t(3UL) << MemVT.SimpleTy*2);
|
||||
TruncStoreActions[ValVT.SimpleTy] |= (uint64_t)Action << MemVT.SimpleTy*2;
|
||||
TruncStoreActions[ValVT.SimpleTy][MemVT.SimpleTy] = (uint8_t)Action;
|
||||
}
|
||||
|
||||
/// setIndexedLoadAction - Indicate that the specified indexed load does or
|
||||
@ -1026,9 +1020,12 @@ protected:
|
||||
void setIndexedLoadAction(unsigned IdxMode, MVT VT,
|
||||
LegalizeAction Action) {
|
||||
assert((unsigned)VT.SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
IdxMode < array_lengthof(IndexedModeActions[0][0]) &&
|
||||
IdxMode < ISD::LAST_INDEXED_MODE &&
|
||||
(unsigned)Action < 0xf &&
|
||||
"Table isn't big enough!");
|
||||
IndexedModeActions[(unsigned)VT.SimpleTy][0][IdxMode] = (uint8_t)Action;
|
||||
// Load action are kept in the upper half.
|
||||
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0xf0;
|
||||
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action) <<4;
|
||||
}
|
||||
|
||||
/// setIndexedStoreAction - Indicate that the specified indexed store does or
|
||||
@ -1038,9 +1035,12 @@ protected:
|
||||
void setIndexedStoreAction(unsigned IdxMode, MVT VT,
|
||||
LegalizeAction Action) {
|
||||
assert((unsigned)VT.SimpleTy < MVT::LAST_VALUETYPE &&
|
||||
IdxMode < array_lengthof(IndexedModeActions[0][1] ) &&
|
||||
IdxMode < ISD::LAST_INDEXED_MODE &&
|
||||
(unsigned)Action < 0xf &&
|
||||
"Table isn't big enough!");
|
||||
IndexedModeActions[(unsigned)VT.SimpleTy][1][IdxMode] = (uint8_t)Action;
|
||||
// Store action are kept in the lower half.
|
||||
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0x0f;
|
||||
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action);
|
||||
}
|
||||
|
||||
/// setCondCodeAction - Indicate that the specified condition code is or isn't
|
||||
@ -1596,22 +1596,22 @@ private:
|
||||
uint64_t OpActions[MVT::MAX_ALLOWED_VALUETYPE/(sizeof(uint64_t)*4)]
|
||||
[ISD::BUILTIN_OP_END];
|
||||
|
||||
/// LoadExtActions - For each load of load extension type and each value type,
|
||||
/// LoadExtActions - For each load extension type and each value type,
|
||||
/// keep a LegalizeAction that indicates how instruction selection should deal
|
||||
/// with the load.
|
||||
uint64_t LoadExtActions[ISD::LAST_LOADEXT_TYPE];
|
||||
/// with a load of a specific value type and extension type.
|
||||
uint8_t LoadExtActions[MVT::LAST_VALUETYPE][ISD::LAST_LOADEXT_TYPE];
|
||||
|
||||
/// TruncStoreActions - For each truncating store, keep a LegalizeAction that
|
||||
/// indicates how instruction selection should deal with the store.
|
||||
uint64_t TruncStoreActions[MVT::LAST_VALUETYPE];
|
||||
/// TruncStoreActions - For each value type pair keep a LegalizeAction that
|
||||
/// indicates whether a truncating store of a specific value type and
|
||||
/// truncating type is legal.
|
||||
uint8_t TruncStoreActions[MVT::LAST_VALUETYPE][MVT::LAST_VALUETYPE];
|
||||
|
||||
/// IndexedModeActions - For each indexed mode and each value type,
|
||||
/// keep a pair of LegalizeAction that indicates how instruction
|
||||
/// selection should deal with the load / store. The first
|
||||
/// dimension is now the value_type for the reference. The second
|
||||
/// dimension is the load [0] vs. store[1]. The third dimension
|
||||
/// represents the various modes for load store.
|
||||
uint8_t IndexedModeActions[MVT::LAST_VALUETYPE][2][ISD::LAST_INDEXED_MODE];
|
||||
/// selection should deal with the load / store. The first dimension is the
|
||||
/// value_type for the reference. The second dimension represents the various
|
||||
/// modes for load store.
|
||||
uint8_t IndexedModeActions[MVT::LAST_VALUETYPE][ISD::LAST_INDEXED_MODE];
|
||||
|
||||
/// CondCodeActions - For each condition code (ISD::CondCode) keep a
|
||||
/// LegalizeAction that indicates how instruction selection should
|
||||
|
||||
Loading…
Reference in New Issue
Block a user