lib/Target/TargetTransformImpl.cpp

   1 // llvm/Target/TargetTransformImpl.cpp - Target Loop Trans Info ---*- C++ -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Target/TargetTransformImpl.h"
  11 #include "llvm/Target/TargetLowering.h"
  12 #include <utility>
  13
  14 using namespace llvm;
  15
  16 //===----------------------------------------------------------------------===//
  17 //
  18 // Calls used by scalar transformations.
  19 //
  20 //===----------------------------------------------------------------------===//
  21
  22 bool ScalarTargetTransformImpl::isLegalAddImmediate(int64_t imm) const {
  23   return TLI->isLegalAddImmediate(imm);
  24 }
  25
  26 bool ScalarTargetTransformImpl::isLegalICmpImmediate(int64_t imm) const {
  27   return TLI->isLegalICmpImmediate(imm);
  28 }
  29
  30 bool ScalarTargetTransformImpl::isLegalAddressingMode(const AddrMode &AM,
  31                                                     Type *Ty) const {
  32   return TLI->isLegalAddressingMode(AM, Ty);
  33 }
  34
  35 bool ScalarTargetTransformImpl::isTruncateFree(Type *Ty1, Type *Ty2) const {
  36   return TLI->isTruncateFree(Ty1, Ty2);
  37 }
  38
  39 bool ScalarTargetTransformImpl::isTypeLegal(Type *Ty) const {
  40   EVT T = TLI->getValueType(Ty);
  41   return TLI->isTypeLegal(T);
  42 }
  43
  44 unsigned ScalarTargetTransformImpl::getJumpBufAlignment() const {
  45   return TLI->getJumpBufAlignment();
  46 }
  47
  48 unsigned ScalarTargetTransformImpl::getJumpBufSize() const {
  49   return TLI->getJumpBufSize();
  50 }
  51
  52 //===----------------------------------------------------------------------===//
  53 //
  54 // Calls used by the vectorizers.
  55 //
  56 //===----------------------------------------------------------------------===//
  57 static int InstructionOpcodeToISD(unsigned Opcode) {
  58   enum InstructionOpcodes {
  59 #define HANDLE_INST(NUM, OPCODE, CLASS) OPCODE = NUM,
  60 #define LAST_OTHER_INST(NUM) InstructionOpcodesCount = NUM
  61 #include "llvm/Instruction.def"
  62   };
  63   switch (static_cast<InstructionOpcodes>(Opcode)) {
  64   case Ret:            return 0;
  65   case Br:             return 0;
  66   case Switch:         return 0;
  67   case IndirectBr:     return 0;
  68   case Invoke:         return 0;
  69   case Resume:         return 0;
  70   case Unreachable:    return 0;
  71   case Add:            return ISD::ADD;
  72   case FAdd:           return ISD::FADD;
  73   case Sub:            return ISD::SUB;
  74   case FSub:           return ISD::FSUB;
  75   case Mul:            return ISD::MUL;
  76   case FMul:           return ISD::FMUL;
  77   case UDiv:           return ISD::UDIV;
  78   case SDiv:           return ISD::UDIV;
  79   case FDiv:           return ISD::FDIV;
  80   case URem:           return ISD::UREM;
  81   case SRem:           return ISD::SREM;
  82   case FRem:           return ISD::FREM;
  83   case Shl:            return ISD::SHL;
  84   case LShr:           return ISD::SRL;
  85   case AShr:           return ISD::SRA;
  86   case And:            return ISD::AND;
  87   case Or:             return ISD::OR;
  88   case Xor:            return ISD::XOR;
  89   case Alloca:         return 0;
  90   case Load:           return ISD::LOAD;
  91   case Store:          return ISD::STORE;
  92   case GetElementPtr:  return 0;
  93   case Fence:          return 0;
  94   case AtomicCmpXchg:  return 0;
  95   case AtomicRMW:      return 0;
  96   case Trunc:          return ISD::TRUNCATE;
  97   case ZExt:           return ISD::ZERO_EXTEND;
  98   case SExt:           return ISD::SEXTLOAD;
  99   case FPToUI:         return ISD::FP_TO_UINT;
 100   case FPToSI:         return ISD::FP_TO_SINT;
 101   case UIToFP:         return ISD::UINT_TO_FP;
 102   case SIToFP:         return ISD::SINT_TO_FP;
 103   case FPTrunc:        return ISD::FP_ROUND;
 104   case FPExt:          return ISD::FP_EXTEND;
 105   case PtrToInt:       return ISD::BITCAST;
 106   case IntToPtr:       return ISD::BITCAST;
 107   case BitCast:        return ISD::BITCAST;
 108   case ICmp:           return ISD::SETCC;
 109   case FCmp:           return ISD::SETCC;
 110   case PHI:            return 0;
 111   case Call:           return 0;
 112   case Select:         return ISD::SELECT;
 113   case UserOp1:        return 0;
 114   case UserOp2:        return 0;
 115   case VAArg:          return 0;
 116   case ExtractElement: return ISD::EXTRACT_VECTOR_ELT;
 117   case InsertElement:  return ISD::INSERT_VECTOR_ELT;
 118   case ShuffleVector:  return ISD::VECTOR_SHUFFLE;
 119   case ExtractValue:   return ISD::MERGE_VALUES;
 120   case InsertValue:    return ISD::MERGE_VALUES;
 121   case LandingPad:     return 0;
 122   }
 123
 124   llvm_unreachable("Unknown instruction type encountered!");
 125 }
 126
 127 std::pair<unsigned, EVT>
 128 VectorTargetTransformImpl::getTypeLegalizationCost(LLVMContext &C,
 129                                                    EVT Ty) const {
 130   unsigned Cost = 1;
 131   // We keep legalizing the type until we find a legal kind. We assume that
 132   // the only operation that costs anything is the split. After splitting
 133   // we need to handle two types.
 134   while (true) {
 135     TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, Ty);
 136
 137     if (LK.first == TargetLowering::TypeLegal)
 138       return std::make_pair(Cost, Ty);
 139
 140     if (LK.first == TargetLowering::TypeSplitVector)
 141       Cost *= 2;
 142
 143     // Keep legalizing the type.
 144     Ty = LK.second;
 145   }
 146 }
 147
 148 unsigned
 149 VectorTargetTransformImpl::getScalarizationOverhead(Type *Ty,
 150                                                     bool Insert,
 151                                                     bool Extract) const {
 152   assert (Ty->isVectorTy() && "Can only scalarize vectors");
 153    unsigned Cost = 0;
 154
 155   for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
 156     if (Insert)
 157       Cost += getVectorInstrCost(Instruction::InsertElement, Ty, i);
 158     if (Extract)
 159       Cost += getVectorInstrCost(Instruction::ExtractElement, Ty, i);
 160   }
 161
 162   return Cost;
 163 }
 164
 165 unsigned VectorTargetTransformImpl::getArithmeticInstrCost(unsigned Opcode,
 166                                                            Type *Ty) const {
 167   // Check if any of the operands are vector operands.
 168   int ISD = InstructionOpcodeToISD(Opcode);
 169   assert(ISD && "Invalid opcode");
 170
 171   std::pair<unsigned, EVT> LT =
 172   getTypeLegalizationCost(Ty->getContext(), TLI->getValueType(Ty));
 173
 174   if (!TLI->isOperationExpand(ISD, LT.second)) {
 175     // The operation is legal. Assume it costs 1. Multiply
 176     // by the type-legalization overhead.
 177     return LT.first * 1;
 178   }
 179
 180   // Else, assume that we need to scalarize this op.
 181   if (Ty->isVectorTy()) {
 182     unsigned Num = Ty->getVectorNumElements();
 183     unsigned Cost = getArithmeticInstrCost(Opcode, Ty->getScalarType());
 184     // return the cost of multiple scalar invocation plus the cost of inserting
 185     // and extracting the values.
 186     return getScalarizationOverhead(Ty, true, true) + Num * Cost;
 187   }
 188
 189   // We don't know anything about this scalar instruction.
 190   return 1;
 191 }
 192
 193 unsigned VectorTargetTransformImpl::getBroadcastCost(Type *Tp) const {
 194   return 1;
 195 }
 196
 197 unsigned VectorTargetTransformImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
 198                                   Type *Src) const {
 199   assert(Src->isVectorTy() == Dst->isVectorTy() && "Invalid input types");
 200   int ISD = InstructionOpcodeToISD(Opcode);
 201   assert(ISD && "Invalid opcode");
 202
 203   std::pair<unsigned, EVT> SrcLT =
 204   getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
 205
 206   std::pair<unsigned, EVT> DstLT =
 207   getTypeLegalizationCost(Dst->getContext(), TLI->getValueType(Dst));
 208
 209   // If the cast is between same-sized registers, then the check is simple.
 210   if (SrcLT.first == DstLT.first &&
 211       SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) {
 212     // Just check the op cost:
 213     if (!TLI->isOperationExpand(ISD, DstLT.second)) {
 214       // The operation is legal. Assume it costs 1. Multiply
 215       // by the type-legalization overhead.
 216       return SrcLT.first * 1;
 217     }
 218   }
 219
 220   // Otherwise, assume that the cast is scalarized.
 221   if (Dst->isVectorTy()) {
 222     unsigned Num = Dst->getVectorNumElements();
 223     unsigned Cost = getCastInstrCost(Opcode, Src->getScalarType(),
 224                                      Dst->getScalarType());
 225     // return the cost of multiple scalar invocation plus the cost of inserting
 226     // and extracting the values.
 227     return getScalarizationOverhead(Dst, true, true) + Num * Cost;
 228   }
 229
 230   // Unknown scalar opcode.
 231   return 1;
 232 }
 233
 234 unsigned VectorTargetTransformImpl::getCFInstrCost(unsigned Opcode) const {
 235   return 1;
 236 }
 237
 238 unsigned VectorTargetTransformImpl::getCmpSelInstrCost(unsigned Opcode,
 239                                                        Type *ValTy,
 240                                                        Type *CondTy) const {
 241   int ISD = InstructionOpcodeToISD(Opcode);
 242   assert(ISD && "Invalid opcode");
 243
 244   // Selects on vectors are actually vector selects.
 245   if (ISD == ISD::SELECT) {
 246     assert(CondTy && "CondTy must exist");
 247     if (CondTy->isVectorTy())
 248       ISD = ISD::VSELECT;
 249   }
 250
 251   std::pair<unsigned, EVT> LT =
 252   getTypeLegalizationCost(ValTy->getContext(), TLI->getValueType(ValTy));
 253
 254   if (!TLI->isOperationExpand(ISD, LT.second)) {
 255     // The operation is legal. Assume it costs 1. Multiply
 256     // by the type-legalization overhead.
 257     return LT.first * 1;
 258   }
 259
 260   // Otherwise, assume that the cast is scalarized.
 261   if (ValTy->isVectorTy()) {
 262     unsigned Num = ValTy->getVectorNumElements();
 263     if (CondTy)
 264       CondTy = CondTy->getScalarType();
 265     unsigned Cost = getCmpSelInstrCost(Opcode, ValTy->getScalarType(),
 266                                        CondTy);
 267
 268     // return the cost of multiple scalar invocation plus the cost of inserting
 269     // and extracting the values.
 270     return getScalarizationOverhead(ValTy, true, false) + Num * Cost;
 271   }
 272
 273   // Unknown scalar opcode.
 274   return 1;
 275 }
 276
 277 /// Returns the expected cost of Vector Insert and Extract.
 278 unsigned VectorTargetTransformImpl::getVectorInstrCost(unsigned Opcode,
 279                                                        Type *Val,
 280                                                        unsigned Index) const {
 281   return 1;
 282 }
 283
 284 unsigned
 285 VectorTargetTransformImpl::getInstrCost(unsigned Opcode, Type *Ty1,
 286                                         Type *Ty2) const {
 287   return 1;
 288 }
 289
 290 unsigned
 291 VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
 292                                            unsigned Alignment,
 293                                            unsigned AddressSpace) const {
 294   std::pair<unsigned, EVT> LT =
 295   getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
 296
 297   // Assume that all loads of legal types cost 1.
 298   return LT.first;
 299 }
 300
 301 unsigned
 302 VectorTargetTransformImpl::getNumberOfParts(Type *Tp) const {
 303   return TLI->getNumRegisters(Tp->getContext(), TLI->getValueType(Tp));
 304 }
 305