From 6595cb3000d7f5f8e9a76d556aa8609db91b7887 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Wed, 27 Jun 2007 16:08:04 +0000 Subject: [PATCH] Rename ("shrinkify") MVT::isExtendedValueType to MVT::isExtendedVT. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37758 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/ValueTypes.h | 12 +++++------ include/llvm/Target/TargetLowering.h | 26 +++++++++++------------ lib/CodeGen/SelectionDAG/LegalizeDAG.cpp | 2 +- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 2 +- lib/VMCore/ValueTypes.cpp | 4 ++-- 5 files changed, 23 insertions(+), 23 deletions(-) diff --git a/include/llvm/CodeGen/ValueTypes.h b/include/llvm/CodeGen/ValueTypes.h index 211bc28123a..d2a6414fcc5 100644 --- a/include/llvm/CodeGen/ValueTypes.h +++ b/include/llvm/CodeGen/ValueTypes.h @@ -95,9 +95,9 @@ namespace MVT { // MVT = Machine Value Types static const uint32_t SimpleTypeMask = (~uint32_t(0) << (32 - SimpleTypeBits)) >> (32 - SimpleTypeBits); - /// MVT::isExtendedValueType - Test if the given ValueType is extended + /// MVT::isExtendedVT - Test if the given ValueType is extended /// (as opposed to being simple). - static inline bool isExtendedValueType(ValueType VT) { + static inline bool isExtendedVT(ValueType VT) { return VT > SimpleTypeMask; } @@ -117,7 +117,7 @@ namespace MVT { // MVT = Machine Value Types /// MVT::isVector - Return true if this is a vector value type. static inline bool isVector(ValueType VT) { return (VT >= FIRST_VECTOR_VALUETYPE && VT <= LAST_VECTOR_VALUETYPE) || - isExtendedValueType(VT); + isExtendedVT(VT); } /// MVT::getVectorElementType - Given a vector type, return the type of @@ -125,7 +125,7 @@ namespace MVT { // MVT = Machine Value Types static inline ValueType getVectorElementType(ValueType VT) { switch (VT) { default: - if (isExtendedValueType(VT)) + if (isExtendedVT(VT)) return VT & SimpleTypeMask; assert(0 && "Invalid vector type!"); case v8i8 : @@ -147,7 +147,7 @@ namespace MVT { // MVT = Machine Value Types static inline unsigned getVectorNumElements(ValueType VT) { switch (VT) { default: - if (isExtendedValueType(VT)) + if (isExtendedVT(VT)) return ((VT & ~SimpleTypeMask) >> SimpleTypeBits) - 1; assert(0 && "Invalid vector type!"); case v16i8: return 16; @@ -170,7 +170,7 @@ namespace MVT { // MVT = Machine Value Types static inline unsigned getSizeInBits(ValueType VT) { switch (VT) { default: - if (isExtendedValueType(VT)) + if (isExtendedVT(VT)) return getSizeInBits(getVectorElementType(VT)) * getVectorNumElements(VT); assert(0 && "ValueType has no known size!"); diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h index 085387faa07..1966a435294 100644 --- a/include/llvm/Target/TargetLowering.h +++ b/include/llvm/Target/TargetLowering.h @@ -120,7 +120,7 @@ public: /// getRegClassFor - Return the register class that should be used for the /// specified value type. This may only be called on legal types. TargetRegisterClass *getRegClassFor(MVT::ValueType VT) const { - assert(!MVT::isExtendedValueType(VT)); + assert(!MVT::isExtendedVT(VT)); TargetRegisterClass *RC = RegClassForVT[VT]; assert(RC && "This value type is not natively supported!"); return RC; @@ -130,7 +130,7 @@ public: /// specified value type. This means that it has a register that directly /// holds it without promotions or expansions. bool isTypeLegal(MVT::ValueType VT) const { - return !MVT::isExtendedValueType(VT) && RegClassForVT[VT] != 0; + return !MVT::isExtendedVT(VT) && RegClassForVT[VT] != 0; } class ValueTypeActionImpl { @@ -148,11 +148,11 @@ public: } LegalizeAction getTypeAction(MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) return Expand; + if (MVT::isExtendedVT(VT)) return Expand; return (LegalizeAction)((ValueTypeActions[VT>>4] >> ((2*VT) & 31)) & 3); } void setTypeAction(MVT::ValueType VT, LegalizeAction Action) { - assert(!MVT::isExtendedValueType(VT)); + assert(!MVT::isExtendedVT(VT)); assert(unsigned(VT >> 4) < sizeof(ValueTypeActions)/sizeof(ValueTypeActions[0])); ValueTypeActions[VT>>4] |= Action << ((VT*2) & 31); @@ -178,7 +178,7 @@ public: /// to get to the smaller register. For illegal floating point types, this /// returns the integer type to transform to. MVT::ValueType getTypeToTransformTo(MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) + if (MVT::isExtendedVT(VT)) return MVT::getVectorType(MVT::getVectorElementType(VT), MVT::getVectorNumElements(VT) / 2); @@ -190,7 +190,7 @@ public: /// that are larger than the largest integer register or illegal floating /// point types), this returns the largest legal type it will be expanded to. MVT::ValueType getTypeToExpandTo(MVT::ValueType VT) const { - assert(!MVT::isExtendedValueType(VT)); + assert(!MVT::isExtendedVT(VT)); while (true) { switch (getTypeAction(VT)) { case Legal: @@ -250,7 +250,7 @@ public: /// expanded to some other code sequence, or the target has a custom expander /// for it. LegalizeAction getOperationAction(unsigned Op, MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) return Expand; + if (MVT::isExtendedVT(VT)) return Expand; return (LegalizeAction)((OpActions[Op] >> (2*VT)) & 3); } @@ -266,7 +266,7 @@ public: /// expanded to some other code sequence, or the target has a custom expander /// for it. LegalizeAction getLoadXAction(unsigned LType, MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) return Expand; + if (MVT::isExtendedVT(VT)) return Expand; return (LegalizeAction)((LoadXActions[LType] >> (2*VT)) & 3); } @@ -282,7 +282,7 @@ public: /// expanded to some other code sequence, or the target has a custom expander /// for it. LegalizeAction getStoreXAction(MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) return Expand; + if (MVT::isExtendedVT(VT)) return Expand; return (LegalizeAction)((StoreXActions >> (2*VT)) & 3); } @@ -298,7 +298,7 @@ public: /// for it. LegalizeAction getIndexedLoadAction(unsigned IdxMode, MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) return Expand; + if (MVT::isExtendedVT(VT)) return Expand; return (LegalizeAction)((IndexedModeActions[0][IdxMode] >> (2*VT)) & 3); } @@ -315,7 +315,7 @@ public: /// for it. LegalizeAction getIndexedStoreAction(unsigned IdxMode, MVT::ValueType VT) const { - if (MVT::isExtendedValueType(VT)) return Expand; + if (MVT::isExtendedVT(VT)) return Expand; return (LegalizeAction)((IndexedModeActions[1][IdxMode] >> (2*VT)) & 3); } @@ -365,7 +365,7 @@ public: /// registers, but may be more than one for types (like i64) that are split /// into pieces. unsigned getNumRegisters(MVT::ValueType VT) const { - if (!MVT::isExtendedValueType(VT)) + if (!MVT::isExtendedVT(VT)) return NumRegistersForVT[VT]; MVT::ValueType VT1, VT2; @@ -665,7 +665,7 @@ protected: /// regclass for the specified value type. This indicates the selector can /// handle values of that class natively. void addRegisterClass(MVT::ValueType VT, TargetRegisterClass *RC) { - assert(!MVT::isExtendedValueType(VT)); + assert(!MVT::isExtendedVT(VT)); AvailableRegClasses.push_back(std::make_pair(VT, RC)); RegClassForVT[VT] = RC; } diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index bc94a624f0f..a239aef16c0 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -1714,7 +1714,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { break; case Expand: { SDOperand Lo, Hi; - assert(!MVT::isExtendedValueType(Node->getOperand(i).getValueType())&& + assert(!MVT::isExtendedVT(Node->getOperand(i).getValueType()) && "FIXME: TODO: implement returning non-legal vector types!"); ExpandOp(Node->getOperand(i), Lo, Hi); NewValues.push_back(Lo); diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 5780eff67a7..6dcba0d9d6b 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -2475,7 +2475,7 @@ SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList, } SDVTList SelectionDAG::getVTList(MVT::ValueType VT) { - if (!MVT::isExtendedValueType(VT)) + if (!MVT::isExtendedVT(VT)) return makeVTList(SDNode::getValueTypeList(VT), 1); for (std::list >::iterator I = VTList.begin(), diff --git a/lib/VMCore/ValueTypes.cpp b/lib/VMCore/ValueTypes.cpp index 7472f888e16..0518aa20d77 100644 --- a/lib/VMCore/ValueTypes.cpp +++ b/lib/VMCore/ValueTypes.cpp @@ -22,7 +22,7 @@ using namespace llvm; std::string MVT::getValueTypeString(MVT::ValueType VT) { switch (VT) { default: - if (isExtendedValueType(VT)) + if (isExtendedVT(VT)) return "v" + utostr(getVectorNumElements(VT)) + getValueTypeString(getVectorElementType(VT)); assert(0 && "Invalid ValueType!"); @@ -59,7 +59,7 @@ std::string MVT::getValueTypeString(MVT::ValueType VT) { const Type *MVT::getTypeForValueType(MVT::ValueType VT) { switch (VT) { default: - if (isExtendedValueType(VT)) + if (isExtendedVT(VT)) return VectorType::get(getTypeForValueType(getVectorElementType(VT)), getVectorNumElements(VT)); assert(0 && "ValueType does not correspond to LLVM type!");