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 bool ScalarTargetTransformImpl::shouldBuildLookupTables() const {
  53   return TLI->supportJumpTables() &&
  54       (TLI->isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
  55        TLI->isOperationLegalOrCustom(ISD::BRIND, MVT::Other));
  56 }
  57
  58 //===----------------------------------------------------------------------===//
  59 //
  60 // Calls used by the vectorizers.
  61 //
  62 //===----------------------------------------------------------------------===//
  63 int VectorTargetTransformImpl::InstructionOpcodeToISD(unsigned Opcode) const {
  64   enum InstructionOpcodes {
  65 #define HANDLE_INST(NUM, OPCODE, CLASS) OPCODE = NUM,
  66 #define LAST_OTHER_INST(NUM) InstructionOpcodesCount = NUM
  67 #include "llvm/IR/Instruction.def"
  68   };
  69   switch (static_cast<InstructionOpcodes>(Opcode)) {
  70   case Ret:            return 0;
  71   case Br:             return 0;
  72   case Switch:         return 0;
  73   case IndirectBr:     return 0;
  74   case Invoke:         return 0;
  75   case Resume:         return 0;
  76   case Unreachable:    return 0;
  77   case Add:            return ISD::ADD;
  78   case FAdd:           return ISD::FADD;
  79   case Sub:            return ISD::SUB;
  80   case FSub:           return ISD::FSUB;
  81   case Mul:            return ISD::MUL;
  82   case FMul:           return ISD::FMUL;
  83   case UDiv:           return ISD::UDIV;
  84   case SDiv:           return ISD::UDIV;
  85   case FDiv:           return ISD::FDIV;
  86   case URem:           return ISD::UREM;
  87   case SRem:           return ISD::SREM;
  88   case FRem:           return ISD::FREM;
  89   case Shl:            return ISD::SHL;
  90   case LShr:           return ISD::SRL;
  91   case AShr:           return ISD::SRA;
  92   case And:            return ISD::AND;
  93   case Or:             return ISD::OR;
  94   case Xor:            return ISD::XOR;
  95   case Alloca:         return 0;
  96   case Load:           return ISD::LOAD;
  97   case Store:          return ISD::STORE;
  98   case GetElementPtr:  return 0;
  99   case Fence:          return 0;
 100   case AtomicCmpXchg:  return 0;
 101   case AtomicRMW:      return 0;
 102   case Trunc:          return ISD::TRUNCATE;
 103   case ZExt:           return ISD::ZERO_EXTEND;
 104   case SExt:           return ISD::SIGN_EXTEND;
 105   case FPToUI:         return ISD::FP_TO_UINT;
 106   case FPToSI:         return ISD::FP_TO_SINT;
 107   case UIToFP:         return ISD::UINT_TO_FP;
 108   case SIToFP:         return ISD::SINT_TO_FP;
 109   case FPTrunc:        return ISD::FP_ROUND;
 110   case FPExt:          return ISD::FP_EXTEND;
 111   case PtrToInt:       return ISD::BITCAST;
 112   case IntToPtr:       return ISD::BITCAST;
 113   case BitCast:        return ISD::BITCAST;
 114   case ICmp:           return ISD::SETCC;
 115   case FCmp:           return ISD::SETCC;
 116   case PHI:            return 0;
 117   case Call:           return 0;
 118   case Select:         return ISD::SELECT;
 119   case UserOp1:        return 0;
 120   case UserOp2:        return 0;
 121   case VAArg:          return 0;
 122   case ExtractElement: return ISD::EXTRACT_VECTOR_ELT;
 123   case InsertElement:  return ISD::INSERT_VECTOR_ELT;
 124   case ShuffleVector:  return ISD::VECTOR_SHUFFLE;
 125   case ExtractValue:   return ISD::MERGE_VALUES;
 126   case InsertValue:    return ISD::MERGE_VALUES;
 127   case LandingPad:     return 0;
 128   }
 129
 130   llvm_unreachable("Unknown instruction type encountered!");
 131 }
 132
 133 std::pair<unsigned, MVT>
 134 VectorTargetTransformImpl::getTypeLegalizationCost(Type *Ty) const {
 135   LLVMContext &C = Ty->getContext();
 136   EVT MTy = TLI->getValueType(Ty);
 137
 138   unsigned Cost = 1;
 139   // We keep legalizing the type until we find a legal kind. We assume that
 140   // the only operation that costs anything is the split. After splitting
 141   // we need to handle two types.
 142   while (true) {
 143     TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, MTy);
 144
 145     if (LK.first == TargetLowering::TypeLegal)
 146       return std::make_pair(Cost, MTy.getSimpleVT());
 147
 148     if (LK.first == TargetLowering::TypeSplitVector ||
 149         LK.first == TargetLowering::TypeExpandInteger)
 150       Cost *= 2;
 151
 152     // Keep legalizing the type.
 153     MTy = LK.second;
 154   }
 155 }
 156
 157 unsigned
 158 VectorTargetTransformImpl::getScalarizationOverhead(Type *Ty,
 159                                                     bool Insert,
 160                                                     bool Extract) const {
 161   assert (Ty->isVectorTy() && "Can only scalarize vectors");
 162   unsigned Cost = 0;
 163
 164   for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
 165     if (Insert)
 166       Cost += getVectorInstrCost(Instruction::InsertElement, Ty, i);
 167     if (Extract)
 168       Cost += getVectorInstrCost(Instruction::ExtractElement, Ty, i);
 169   }
 170
 171   return Cost;
 172 }
 173
 174 unsigned VectorTargetTransformImpl::getNumberOfRegisters(bool Vector) const {
 175   return 1;
 176 }
 177
 178 unsigned VectorTargetTransformImpl::getArithmeticInstrCost(unsigned Opcode,
 179                                                            Type *Ty) const {
 180   // Check if any of the operands are vector operands.
 181   int ISD = InstructionOpcodeToISD(Opcode);
 182   assert(ISD && "Invalid opcode");
 183
 184   std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Ty);
 185
 186   if (TLI->isOperationLegalOrPromote(ISD, LT.second)) {
 187     // The operation is legal. Assume it costs 1.
 188     // If the type is split to multiple registers, assume that thre is some
 189     // overhead to this.
 190     // TODO: Once we have extract/insert subvector cost we need to use them.
 191     if (LT.first > 1)
 192       return LT.first * 2;
 193     return LT.first * 1;
 194   }
 195
 196   if (!TLI->isOperationExpand(ISD, LT.second)) {
 197     // If the operation is custom lowered then assume
 198     // thare the code is twice as expensive.
 199     return LT.first * 2;
 200   }
 201
 202   // Else, assume that we need to scalarize this op.
 203   if (Ty->isVectorTy()) {
 204     unsigned Num = Ty->getVectorNumElements();
 205     unsigned Cost = getArithmeticInstrCost(Opcode, Ty->getScalarType());
 206     // return the cost of multiple scalar invocation plus the cost of inserting
 207     // and extracting the values.
 208     return getScalarizationOverhead(Ty, true, true) + Num * Cost;
 209   }
 210
 211   // We don't know anything about this scalar instruction.
 212   return 1;
 213 }
 214
 215 unsigned VectorTargetTransformImpl::getShuffleCost(ShuffleKind Kind,
 216                                   Type *Tp, int Index, Type *SubTp) const {
 217   return 1;
 218 }
 219
 220 unsigned VectorTargetTransformImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
 221                                   Type *Src) const {
 222   int ISD = InstructionOpcodeToISD(Opcode);
 223   assert(ISD && "Invalid opcode");
 224
 225   std::pair<unsigned, MVT> SrcLT = getTypeLegalizationCost(Src);
 226   std::pair<unsigned, MVT> DstLT = getTypeLegalizationCost(Dst);
 227
 228   // Handle scalar conversions.
 229   if (!Src->isVectorTy() && !Dst->isVectorTy()) {
 230
 231     // Scalar bitcasts are usually free.
 232     if (Opcode == Instruction::BitCast)
 233       return 0;
 234
 235     if (Opcode == Instruction::Trunc &&
 236         TLI->isTruncateFree(SrcLT.second, DstLT.second))
 237       return 0;
 238
 239     if (Opcode == Instruction::ZExt &&
 240         TLI->isZExtFree(SrcLT.second, DstLT.second))
 241       return 0;
 242
 243     // Just check the op cost. If the operation is legal then assume it costs 1.
 244     if (!TLI->isOperationExpand(ISD, DstLT.second))
 245       return  1;
 246
 247     // Assume that illegal scalar instruction are expensive.
 248     return 4;
 249   }
 250
 251   // Check vector-to-vector casts.
 252   if (Dst->isVectorTy() && Src->isVectorTy()) {
 253
 254     // If the cast is between same-sized registers, then the check is simple.
 255     if (SrcLT.first == DstLT.first &&
 256         SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) {
 257
 258       // Bitcast between types that are legalized to the same type are free.
 259       if (Opcode == Instruction::BitCast || Opcode == Instruction::Trunc)
 260         return 0;
 261
 262       // Assume that Zext is done using AND.
 263       if (Opcode == Instruction::ZExt)
 264         return 1;
 265
 266       // Assume that sext is done using SHL and SRA.
 267       if (Opcode == Instruction::SExt)
 268         return 2;
 269
 270       // Just check the op cost. If the operation is legal then assume it costs
 271       // 1 and multiply by the type-legalization overhead.
 272       if (!TLI->isOperationExpand(ISD, DstLT.second))
 273         return SrcLT.first * 1;
 274     }
 275
 276     // If we are converting vectors and the operation is illegal, or
 277     // if the vectors are legalized to different types, estimate the
 278     // scalarization costs.
 279     unsigned Num = Dst->getVectorNumElements();
 280     unsigned Cost = getCastInstrCost(Opcode, Dst->getScalarType(),
 281                                      Src->getScalarType());
 282
 283     // Return the cost of multiple scalar invocation plus the cost of
 284     // inserting and extracting the values.
 285     return getScalarizationOverhead(Dst, true, true) + Num * Cost;
 286   }
 287
 288   // We already handled vector-to-vector and scalar-to-scalar conversions. This
 289   // is where we handle bitcast between vectors and scalars. We need to assume
 290   //  that the conversion is scalarized in one way or another.
 291   if (Opcode == Instruction::BitCast)
 292     // Illegal bitcasts are done by storing and loading from a stack slot.
 293     return (Src->isVectorTy()? getScalarizationOverhead(Src, false, true):0) +
 294            (Dst->isVectorTy()? getScalarizationOverhead(Dst, true, false):0);
 295
 296   llvm_unreachable("Unhandled cast");
 297  }
 298
 299 unsigned VectorTargetTransformImpl::getCFInstrCost(unsigned Opcode) const {
 300   // Branches are assumed to be predicted.
 301   return 0;
 302 }
 303
 304 unsigned VectorTargetTransformImpl::getCmpSelInstrCost(unsigned Opcode,
 305                                                        Type *ValTy,
 306                                                        Type *CondTy) const {
 307   int ISD = InstructionOpcodeToISD(Opcode);
 308   assert(ISD && "Invalid opcode");
 309
 310   // Selects on vectors are actually vector selects.
 311   if (ISD == ISD::SELECT) {
 312     assert(CondTy && "CondTy must exist");
 313     if (CondTy->isVectorTy())
 314       ISD = ISD::VSELECT;
 315   }
 316
 317   std::pair<unsigned, MVT> LT = getTypeLegalizationCost(ValTy);
 318
 319   if (!TLI->isOperationExpand(ISD, LT.second)) {
 320     // The operation is legal. Assume it costs 1. Multiply
 321     // by the type-legalization overhead.
 322     return LT.first * 1;
 323   }
 324
 325   // Otherwise, assume that the cast is scalarized.
 326   if (ValTy->isVectorTy()) {
 327     unsigned Num = ValTy->getVectorNumElements();
 328     if (CondTy)
 329       CondTy = CondTy->getScalarType();
 330     unsigned Cost = getCmpSelInstrCost(Opcode, ValTy->getScalarType(),
 331                                        CondTy);
 332
 333     // Return the cost of multiple scalar invocation plus the cost of inserting
 334     // and extracting the values.
 335     return getScalarizationOverhead(ValTy, true, false) + Num * Cost;
 336   }
 337
 338   // Unknown scalar opcode.
 339   return 1;
 340 }
 341
 342 unsigned VectorTargetTransformImpl::getVectorInstrCost(unsigned Opcode,
 343                                                        Type *Val,
 344                                                        unsigned Index) const {
 345   return 1;
 346 }
 347
 348 unsigned
 349 VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
 350                                            unsigned Alignment,
 351                                            unsigned AddressSpace) const {
 352   assert(!Src->isVoidTy() && "Invalid type");
 353   std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Src);
 354
 355   // Assume that all loads of legal types cost 1.
 356   return LT.first;
 357 }
 358
 359 unsigned
 360 VectorTargetTransformImpl::getIntrinsicInstrCost(Intrinsic::ID, Type *RetTy,
 361                                                  ArrayRef<Type*> Tys) const {
 362   // assume that we need to scalarize this intrinsic.
 363   unsigned ScalarizationCost = 0;
 364   unsigned ScalarCalls = 1;
 365   if (RetTy->isVectorTy()) {
 366     ScalarizationCost = getScalarizationOverhead(RetTy, true, false);
 367     ScalarCalls = std::max(ScalarCalls, RetTy->getVectorNumElements());
 368   }
 369   for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {
 370     if (Tys[i]->isVectorTy()) {
 371       ScalarizationCost += getScalarizationOverhead(Tys[i], false, true);
 372       ScalarCalls = std::max(ScalarCalls, RetTy->getVectorNumElements());
 373     }
 374   }
 375   return ScalarCalls + ScalarizationCost;
 376 }
 377
 378 unsigned
 379 VectorTargetTransformImpl::getNumberOfParts(Type *Tp) const {
 380   std::pair<unsigned, MVT> LT = getTypeLegalizationCost(Tp);
 381   return LT.first;
 382 }