TargetLowering.cpp revision ee4a76563a84839453588104e94d4891fc44d625 
1//===-- TargetLowering.cpp - Implement the TargetLowering class -----------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This implements the TargetLowering class.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Target/TargetLowering.h"
15#include "llvm/Target/TargetMachine.h"
16#include "llvm/CodeGen/SelectionDAG.h"
17using namespace llvm;
18
19TargetLowering::TargetLowering(TargetMachine &tm)
20  : TM(tm), TD(TM.getTargetData()), ValueTypeActions(0) {
21  assert(ISD::BUILTIN_OP_END <= 128 &&
22         "Fixed size array in TargetLowering is not large enough!");
23  // All operations default to being supported.
24  memset(OpActions, 0, sizeof(OpActions));
25
26  IsLittleEndian = TD.isLittleEndian();
27  ShiftAmountTy = SetCCResultTy = PointerTy = getValueType(TD.getIntPtrType());
28  ShiftAmtHandling = Undefined;
29  memset(RegClassForVT, 0,MVT::LAST_VALUETYPE*sizeof(TargetRegisterClass*));
30  maxStoresPerMemSet = maxStoresPerMemCpy = maxStoresPerMemMove = 8;
31  allowUnalignedMemoryAccesses = false;
32  UseUnderscoreSetJmpLongJmp = false;
33  IntDivIsCheap = false;
34  Pow2DivIsCheap = false;
35  StackPointerRegisterToSaveRestore = 0;
36  SchedPreferenceInfo = SchedulingForLatency;
37}
38
39TargetLowering::~TargetLowering() {}
40
41/// setValueTypeAction - Set the action for a particular value type.  This
42/// assumes an action has not already been set for this value type.
43static void SetValueTypeAction(MVT::ValueType VT,
44                               TargetLowering::LegalizeAction Action,
45                               TargetLowering &TLI,
46                               MVT::ValueType *TransformToType,
47                               unsigned long long &ValueTypeActions) {
48  ValueTypeActions |= (unsigned long long)Action << (VT*2);
49  if (Action == TargetLowering::Promote) {
50    MVT::ValueType PromoteTo;
51    if (VT == MVT::f32)
52      PromoteTo = MVT::f64;
53    else {
54      unsigned LargerReg = VT+1;
55      while (!TLI.isTypeLegal((MVT::ValueType)LargerReg)) {
56        ++LargerReg;
57        assert(MVT::isInteger((MVT::ValueType)LargerReg) &&
58               "Nothing to promote to??");
59      }
60      PromoteTo = (MVT::ValueType)LargerReg;
61    }
62
63    assert(MVT::isInteger(VT) == MVT::isInteger(PromoteTo) &&
64           MVT::isFloatingPoint(VT) == MVT::isFloatingPoint(PromoteTo) &&
65           "Can only promote from int->int or fp->fp!");
66    assert(VT < PromoteTo && "Must promote to a larger type!");
67    TransformToType[VT] = PromoteTo;
68  } else if (Action == TargetLowering::Expand) {
69    assert((VT == MVT::Vector || MVT::isInteger(VT)) && VT > MVT::i8 &&
70           "Cannot expand this type: target must support SOME integer reg!");
71    // Expand to the next smaller integer type!
72    TransformToType[VT] = (MVT::ValueType)(VT-1);
73  }
74}
75
76
77/// computeRegisterProperties - Once all of the register classes are added,
78/// this allows us to compute derived properties we expose.
79void TargetLowering::computeRegisterProperties() {
80  assert(MVT::LAST_VALUETYPE <= 32 &&
81         "Too many value types for ValueTypeActions to hold!");
82
83  // Everything defaults to one.
84  for (unsigned i = 0; i != MVT::LAST_VALUETYPE; ++i)
85    NumElementsForVT[i] = 1;
86
87  // Find the largest integer register class.
88  unsigned LargestIntReg = MVT::i128;
89  for (; RegClassForVT[LargestIntReg] == 0; --LargestIntReg)
90    assert(LargestIntReg != MVT::i1 && "No integer registers defined!");
91
92  // Every integer value type larger than this largest register takes twice as
93  // many registers to represent as the previous ValueType.
94  unsigned ExpandedReg = LargestIntReg; ++LargestIntReg;
95  for (++ExpandedReg; MVT::isInteger((MVT::ValueType)ExpandedReg);++ExpandedReg)
96    NumElementsForVT[ExpandedReg] = 2*NumElementsForVT[ExpandedReg-1];
97
98  // Inspect all of the ValueType's possible, deciding how to process them.
99  for (unsigned IntReg = MVT::i1; IntReg <= MVT::i128; ++IntReg)
100    // If we are expanding this type, expand it!
101    if (getNumElements((MVT::ValueType)IntReg) != 1)
102      SetValueTypeAction((MVT::ValueType)IntReg, Expand, *this, TransformToType,
103                         ValueTypeActions);
104    else if (!isTypeLegal((MVT::ValueType)IntReg))
105      // Otherwise, if we don't have native support, we must promote to a
106      // larger type.
107      SetValueTypeAction((MVT::ValueType)IntReg, Promote, *this,
108                         TransformToType, ValueTypeActions);
109    else
110      TransformToType[(MVT::ValueType)IntReg] = (MVT::ValueType)IntReg;
111
112  // If the target does not have native support for F32, promote it to F64.
113  if (!isTypeLegal(MVT::f32))
114    SetValueTypeAction(MVT::f32, Promote, *this,
115                       TransformToType, ValueTypeActions);
116  else
117    TransformToType[MVT::f32] = MVT::f32;
118
119  // Set MVT::Vector to always be Expanded
120  SetValueTypeAction(MVT::Vector, Expand, *this, TransformToType,
121                     ValueTypeActions);
122
123  assert(isTypeLegal(MVT::f64) && "Target does not support FP?");
124  TransformToType[MVT::f64] = MVT::f64;
125}
126
127const char *TargetLowering::getTargetNodeName(unsigned Opcode) const {
128  return NULL;
129}
130
131bool TargetLowering::isMaskedValueZeroForTargetNode(const SDOperand &Op,
132                                                    uint64_t Mask) const {
133  return false;
134}
135