[llvm-commits] [llvm] r167422 - in /llvm/trunk: include/llvm/Target/TargetTransformImpl.h lib/Target/TargetTransformImpl.cpp lib/Target/X86/X86ISelLowering.cpp

[Nadav Rotem]

Author: nadav
Date: Mon Nov  5 17:57:45 2012
New Revision: 167422

URL: http://llvm.org/viewvc/llvm-project?rev=167422&view=rev
Log:
Refactor the getTypeLegalizationCost interface. No functionality change.

Modified:
    llvm/trunk/include/llvm/Target/TargetTransformImpl.h
    llvm/trunk/lib/Target/TargetTransformImpl.cpp
    llvm/trunk/lib/Target/X86/X86ISelLowering.cpp

Modified: llvm/trunk/include/llvm/Target/TargetTransformImpl.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Target/TargetTransformImpl.h?rev=167422&r1=167421&r2=167422&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Target/TargetTransformImpl.h (original)
+++ llvm/trunk/include/llvm/Target/TargetTransformImpl.h Mon Nov  5 17:57:45 2012
@@ -55,8 +55,7 @@
   const TargetLowering *TLI;
 
   /// Estimate the cost of type-legalization and the legalized type.
-  std::pair<unsigned, MVT>
-  getTypeLegalizationCost(LLVMContext &C, EVT Ty) const;
+  std::pair<unsigned, MVT> getTypeLegalizationCost(Type *Ty) const;
 
   /// Estimate the overhead of scalarizing an instruction. Insert and Extract
   /// are set if the result needs to be inserted and/or extracted from vectors.

Modified: llvm/trunk/lib/Target/TargetTransformImpl.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/TargetTransformImpl.cpp?rev=167422&r1=167421&r2=167422&view=diff
==============================================================================
--- llvm/trunk/lib/Target/TargetTransformImpl.cpp (original)
+++ llvm/trunk/lib/Target/TargetTransformImpl.cpp Mon Nov  5 17:57:45 2012
@@ -131,24 +131,27 @@
 }
 
 std::pair<unsigned, MVT>
-VectorTargetTransformImpl::getTypeLegalizationCost(LLVMContext &C,
-                                                   EVT Ty) const {
+VectorTargetTransformImpl::getTypeLegalizationCost(Type *Ty) const {
+
+  LLVMContext &C = Ty->getContext();
+  EVT MTy = TLI->getValueType(Ty);
+
   unsigned Cost = 1;
   // We keep legalizing the type until we find a legal kind. We assume that
   // the only operation that costs anything is the split. After splitting
   // we need to handle two types.
   while (true) {
-    TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, Ty);
+    TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, MTy);
 
     if (LK.first == TargetLowering::TypeLegal)
-      return std::make_pair(Cost, Ty.getSimpleVT());
+      return std::make_pair(Cost, MTy.getSimpleVT());
 
     if (LK.first == TargetLowering::TypeSplitVector ||
         LK.first == TargetLowering::TypeExpandInteger)
       Cost *= 2;
 
     // Keep legalizing the type.
-    Ty = LK.second;
+    MTy = LK.second;
   }
 }
 
@@ -175,8 +178,7 @@
   int ISD = InstructionOpcodeToISD(Opcode);
   assert(ISD && "Invalid opcode");
 
-  std::pair<unsigned, MVT> LT =
-  getTypeLegalizationCost(Ty->getContext(), TLI->getValueType(Ty));
+  std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Ty);
 
   if (!TLI->isOperationExpand(ISD, LT.second)) {
     // The operation is legal. Assume it costs 1. Multiply
@@ -206,11 +208,8 @@
   int ISD = InstructionOpcodeToISD(Opcode);
   assert(ISD && "Invalid opcode");
 
-  std::pair<unsigned, MVT> SrcLT =
-  getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
-
-  std::pair<unsigned, MVT> DstLT =
-  getTypeLegalizationCost(Dst->getContext(), TLI->getValueType(Dst));
+  std::pair<unsigned, MVT> SrcLT = getTypeLegalizationCost(Src);
+  std::pair<unsigned, MVT> DstLT = getTypeLegalizationCost(Dst);
 
   // Handle scalar conversions.
   if (!Src->isVectorTy() && !Dst->isVectorTy()) {
@@ -292,8 +291,7 @@
       ISD = ISD::VSELECT;
   }
 
-  std::pair<unsigned, MVT> LT =
-  getTypeLegalizationCost(ValTy->getContext(), TLI->getValueType(ValTy));
+  std::pair<unsigned, MVT> LT = getTypeLegalizationCost(ValTy);
 
   if (!TLI->isOperationExpand(ISD, LT.second)) {
     // The operation is legal. Assume it costs 1. Multiply
@@ -334,8 +332,7 @@
 VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
                                            unsigned Alignment,
                                            unsigned AddressSpace) const {
-  std::pair<unsigned, MVT> LT =
-  getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
+  std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Src);
 
   // Assume that all loads of legal types cost 1.
   return LT.first;
@@ -343,7 +340,6 @@
 
 unsigned
 VectorTargetTransformImpl::getNumberOfParts(Type *Tp) const {
-  std::pair<unsigned, MVT> LT =
-    getTypeLegalizationCost(Tp->getContext(), TLI->getValueType(Tp));
+  std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Tp);
   return LT.first;
 }

Modified: llvm/trunk/lib/Target/X86/X86ISelLowering.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86ISelLowering.cpp?rev=167422&r1=167421&r2=167422&view=diff
==============================================================================
--- llvm/trunk/lib/Target/X86/X86ISelLowering.cpp (original)
+++ llvm/trunk/lib/Target/X86/X86ISelLowering.cpp Mon Nov  5 17:57:45 2012
@@ -17530,8 +17530,7 @@
 X86VectorTargetTransformInfo::getArithmeticInstrCost(unsigned Opcode,
                                                      Type *Ty) const {
   // Legalize the type.
-  std::pair<unsigned, MVT> LT =
-  getTypeLegalizationCost(Ty->getContext(), TLI->getValueType(Ty));
+  std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Ty);
 
   int ISD = InstructionOpcodeToISD(Opcode);
   assert(ISD && "Invalid opcode");
@@ -17569,8 +17568,7 @@
 
   if (Index != -1U) {
     // Legalize the type.
-    std::pair<unsigned, MVT> LT =
-    getTypeLegalizationCost(Val->getContext(), TLI->getValueType(Val));
+    std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Val);
 
     // This type is legalized to a scalar type.
     if (!LT.second.isVector())
@@ -17592,8 +17590,7 @@
                                                           Type *ValTy,
                                                           Type *CondTy) const {
   // Legalize the type.
-  std::pair<unsigned, MVT> LT =
-  getTypeLegalizationCost(ValTy->getContext(), TLI->getValueType(ValTy));
+  std::pair<unsigned, MVT> LT = getTypeLegalizationCost(ValTy);
 
   MVT MTy = LT.second;