Fix a bug in the cost calculation of vector casts. Detect situations where bitcasts...
[oota-llvm.git] / 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 static int InstructionOpcodeToISD(unsigned Opcode) {
64   enum InstructionOpcodes {
65 #define HANDLE_INST(NUM, OPCODE, CLASS) OPCODE = NUM,
66 #define LAST_OTHER_INST(NUM) InstructionOpcodesCount = NUM
67 #include "llvm/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::SEXTLOAD;
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, EVT>
134 VectorTargetTransformImpl::getTypeLegalizationCost(LLVMContext &C,
135                                                    EVT Ty) const {
136   unsigned Cost = 1;
137   // We keep legalizing the type until we find a legal kind. We assume that
138   // the only operation that costs anything is the split. After splitting
139   // we need to handle two types.
140   while (true) {
141     TargetLowering::LegalizeKind LK = TLI->getTypeConversion(C, Ty);
142
143     if (LK.first == TargetLowering::TypeLegal)
144       return std::make_pair(Cost, Ty);
145
146     if (LK.first == TargetLowering::TypeSplitVector)
147       Cost *= 2;
148
149     // Keep legalizing the type.
150     Ty = LK.second;
151   }
152 }
153
154 unsigned
155 VectorTargetTransformImpl::getScalarizationOverhead(Type *Ty,
156                                                     bool Insert,
157                                                     bool Extract) const {
158   assert (Ty->isVectorTy() && "Can only scalarize vectors");
159   unsigned Cost = 0;
160
161   for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
162     if (Insert)
163       Cost += getVectorInstrCost(Instruction::InsertElement, Ty, i);
164     if (Extract)
165       Cost += getVectorInstrCost(Instruction::ExtractElement, Ty, i);
166   }
167
168   return Cost;
169 }
170
171 unsigned VectorTargetTransformImpl::getArithmeticInstrCost(unsigned Opcode,
172                                                            Type *Ty) const {
173   // Check if any of the operands are vector operands.
174   int ISD = InstructionOpcodeToISD(Opcode);
175   assert(ISD && "Invalid opcode");
176
177   std::pair<unsigned, EVT> LT =
178   getTypeLegalizationCost(Ty->getContext(), TLI->getValueType(Ty));
179
180   if (!TLI->isOperationExpand(ISD, LT.second)) {
181     // The operation is legal. Assume it costs 1. Multiply
182     // by the type-legalization overhead.
183     return LT.first * 1;
184   }
185
186   // Else, assume that we need to scalarize this op.
187   if (Ty->isVectorTy()) {
188     unsigned Num = Ty->getVectorNumElements();
189     unsigned Cost = getArithmeticInstrCost(Opcode, Ty->getScalarType());
190     // return the cost of multiple scalar invocation plus the cost of inserting
191     // and extracting the values.
192     return getScalarizationOverhead(Ty, true, true) + Num * Cost;
193   }
194
195   // We don't know anything about this scalar instruction.
196   return 1;
197 }
198
199 unsigned VectorTargetTransformImpl::getBroadcastCost(Type *Tp) const {
200   return 1;
201 }
202
203 unsigned VectorTargetTransformImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
204                                   Type *Src) const {
205   int ISD = InstructionOpcodeToISD(Opcode);
206   assert(ISD && "Invalid opcode");
207
208   std::pair<unsigned, EVT> SrcLT =
209   getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
210
211   std::pair<unsigned, EVT> DstLT =
212   getTypeLegalizationCost(Dst->getContext(), TLI->getValueType(Dst));
213
214   // Handle scalar conversions.
215   if (!Src->isVectorTy() && !Dst->isVectorTy()) {
216     // Just check the op cost. If the operation is legal then assume it costs 1.
217     if (!TLI->isOperationExpand(ISD, DstLT.second))
218       return  1;
219
220     // Assume that illegal scalar instruction are expensive.
221     return 4;
222   }
223
224   // Check vector-to-vector casts.
225   if (Dst->isVectorTy() && Src->isVectorTy()) {
226
227     // If the cast is between same-sized registers, then the check is simple.
228     if (SrcLT.first == DstLT.first &&
229         SrcLT.second.getSizeInBits() == DstLT.second.getSizeInBits()) {
230
231       // Bitcast between types that are legalized to the same type are free.
232       if (Opcode == Instruction::BitCast)
233         return 0;
234
235       // Just check the op cost. If the operation is legal then assume it costs
236       // 1 and multiply by the type-legalization overhead.
237       if (!TLI->isOperationExpand(ISD, DstLT.second))
238         return SrcLT.first * 1;
239     }
240
241     // If we are converting vectors and the operation is illegal, or
242     // if the vectors are legalized to different types, estimate the
243     // scalarization costs.
244     unsigned Num = Dst->getVectorNumElements();
245     unsigned Cost = getCastInstrCost(Opcode, Dst->getScalarType(),
246                                      Src->getScalarType());
247
248     // Return the cost of multiple scalar invocation plus the cost of
249     // inserting and extracting the values.
250     return getScalarizationOverhead(Dst, true, true) + Num * Cost;
251   }
252
253   // We already handled vector-to-vector and scalar-to-scalar conversions. This 
254   // is where we handle bitcast between vectors and scalars. We need to assume
255   //  that the conversion is scalarized in one way or another.
256   if (Opcode == Instruction::BitCast)
257     // Illegal bitcasts are done by storing and loading from a stack slot.
258     return (Src->isVectorTy()? getScalarizationOverhead(Src, false, true):0) +
259            (Dst->isVectorTy()? getScalarizationOverhead(Dst, true, false):0);
260
261   llvm_unreachable("Unhandled cast");
262  }
263
264 unsigned VectorTargetTransformImpl::getCFInstrCost(unsigned Opcode) const {
265   return 1;
266 }
267
268 unsigned VectorTargetTransformImpl::getCmpSelInstrCost(unsigned Opcode,
269                                                        Type *ValTy,
270                                                        Type *CondTy) const {
271   int ISD = InstructionOpcodeToISD(Opcode);
272   assert(ISD && "Invalid opcode");
273
274   // Selects on vectors are actually vector selects.
275   if (ISD == ISD::SELECT) {
276     assert(CondTy && "CondTy must exist");
277     if (CondTy->isVectorTy())
278       ISD = ISD::VSELECT;
279   }
280
281   std::pair<unsigned, EVT> LT =
282   getTypeLegalizationCost(ValTy->getContext(), TLI->getValueType(ValTy));
283
284   if (!TLI->isOperationExpand(ISD, LT.second)) {
285     // The operation is legal. Assume it costs 1. Multiply
286     // by the type-legalization overhead.
287     return LT.first * 1;
288   }
289
290   // Otherwise, assume that the cast is scalarized.
291   if (ValTy->isVectorTy()) {
292     unsigned Num = ValTy->getVectorNumElements();
293     if (CondTy)
294       CondTy = CondTy->getScalarType();
295     unsigned Cost = getCmpSelInstrCost(Opcode, ValTy->getScalarType(),
296                                        CondTy);
297
298     // return the cost of multiple scalar invocation plus the cost of inserting
299     // and extracting the values.
300     return getScalarizationOverhead(ValTy, true, false) + Num * Cost;
301   }
302
303   // Unknown scalar opcode.
304   return 1;
305 }
306
307 /// Returns the expected cost of Vector Insert and Extract.
308 unsigned VectorTargetTransformImpl::getVectorInstrCost(unsigned Opcode,
309                                                        Type *Val,
310                                                        unsigned Index) const {
311   return 1;
312 }
313
314 unsigned
315 VectorTargetTransformImpl::getInstrCost(unsigned Opcode, Type *Ty1,
316                                         Type *Ty2) const {
317   return 1;
318 }
319
320 unsigned
321 VectorTargetTransformImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
322                                            unsigned Alignment,
323                                            unsigned AddressSpace) const {
324   std::pair<unsigned, EVT> LT =
325   getTypeLegalizationCost(Src->getContext(), TLI->getValueType(Src));
326
327   // Assume that all loads of legal types cost 1.
328   return LT.first;
329 }
330
331 unsigned
332 VectorTargetTransformImpl::getNumberOfParts(Type *Tp) const {
333   std::pair<unsigned, EVT> LT =
334     getTypeLegalizationCost(Tp->getContext(), TLI->getValueType(Tp));
335   return LT.first;
336 }