lib/Target/ARM/ARMSelectionDAGInfo.cpp

   1 //===-- ARMSelectionDAGInfo.cpp - ARM SelectionDAG Info -------------------===//
   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 // This file implements the ARMSelectionDAGInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "arm-selectiondag-info"
  15 #include "ARMTargetMachine.h"
  16 using namespace llvm;
  17
  18 ARMSelectionDAGInfo::ARMSelectionDAGInfo(const TargetMachine &TM)
  19   : TargetSelectionDAGInfo(TM),
  20     Subtarget(&TM.getSubtarget<ARMSubtarget>()) {
  21 }
  22
  23 ARMSelectionDAGInfo::~ARMSelectionDAGInfo() {
  24 }
  25
  26 SDValue
  27 ARMSelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl,
  28                                              SDValue Chain,
  29                                              SDValue Dst, SDValue Src,
  30                                              SDValue Size, unsigned Align,
  31                                              bool isVolatile, bool AlwaysInline,
  32                                              const Value *DstSV,
  33                                              uint64_t DstSVOff,
  34                                              const Value *SrcSV,
  35                                              uint64_t SrcSVOff) const {
  36   // Do repeated 4-byte loads and stores. To be improved.
  37   // This requires 4-byte alignment.
  38   if ((Align & 3) != 0)
  39     return SDValue();
  40   // This requires the copy size to be a constant, preferrably
  41   // within a subtarget-specific limit.
  42   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
  43   if (!ConstantSize)
  44     return SDValue();
  45   uint64_t SizeVal = ConstantSize->getZExtValue();
  46   if (!AlwaysInline && SizeVal > Subtarget->getMaxInlineSizeThreshold())
  47     return SDValue();
  48
  49   unsigned BytesLeft = SizeVal & 3;
  50   unsigned NumMemOps = SizeVal >> 2;
  51   unsigned EmittedNumMemOps = 0;
  52   EVT VT = MVT::i32;
  53   unsigned VTSize = 4;
  54   unsigned i = 0;
  55   const unsigned MAX_LOADS_IN_LDM = 6;
  56   SDValue TFOps[MAX_LOADS_IN_LDM];
  57   SDValue Loads[MAX_LOADS_IN_LDM];
  58   uint64_t SrcOff = 0, DstOff = 0;
  59
  60   // Emit up to MAX_LOADS_IN_LDM loads, then a TokenFactor barrier, then the
  61   // same number of stores.  The loads and stores will get combined into
  62   // ldm/stm later on.
  63   while (EmittedNumMemOps < NumMemOps) {
  64     for (i = 0;
  65          i < MAX_LOADS_IN_LDM && EmittedNumMemOps + i < NumMemOps; ++i) {
  66       Loads[i] = DAG.getLoad(VT, dl, Chain,
  67                              DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
  68                                          DAG.getConstant(SrcOff, MVT::i32)),
  69                              SrcSV, SrcSVOff + SrcOff, isVolatile, false, 0);
  70       TFOps[i] = Loads[i].getValue(1);
  71       SrcOff += VTSize;
  72     }
  73     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &TFOps[0], i);
  74
  75     for (i = 0;
  76          i < MAX_LOADS_IN_LDM && EmittedNumMemOps + i < NumMemOps; ++i) {
  77       TFOps[i] = DAG.getStore(Chain, dl, Loads[i],
  78                               DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
  79                                           DAG.getConstant(DstOff, MVT::i32)),
  80                               DstSV, DstSVOff + DstOff, isVolatile, false, 0);
  81       DstOff += VTSize;
  82     }
  83     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &TFOps[0], i);
  84
  85     EmittedNumMemOps += i;
  86   }
  87
  88   if (BytesLeft == 0)
  89     return Chain;
  90
  91   // Issue loads / stores for the trailing (1 - 3) bytes.
  92   unsigned BytesLeftSave = BytesLeft;
  93   i = 0;
  94   while (BytesLeft) {
  95     if (BytesLeft >= 2) {
  96       VT = MVT::i16;
  97       VTSize = 2;
  98     } else {
  99       VT = MVT::i8;
 100       VTSize = 1;
 101     }
 102
 103     Loads[i] = DAG.getLoad(VT, dl, Chain,
 104                            DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
 105                                        DAG.getConstant(SrcOff, MVT::i32)),
 106                            SrcSV, SrcSVOff + SrcOff, false, false, 0);
 107     TFOps[i] = Loads[i].getValue(1);
 108     ++i;
 109     SrcOff += VTSize;
 110     BytesLeft -= VTSize;
 111   }
 112   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &TFOps[0], i);
 113
 114   i = 0;
 115   BytesLeft = BytesLeftSave;
 116   while (BytesLeft) {
 117     if (BytesLeft >= 2) {
 118       VT = MVT::i16;
 119       VTSize = 2;
 120     } else {
 121       VT = MVT::i8;
 122       VTSize = 1;
 123     }
 124
 125     TFOps[i] = DAG.getStore(Chain, dl, Loads[i],
 126                             DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
 127                                         DAG.getConstant(DstOff, MVT::i32)),
 128                             DstSV, DstSVOff + DstOff, false, false, 0);
 129     ++i;
 130     DstOff += VTSize;
 131     BytesLeft -= VTSize;
 132   }
 133   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &TFOps[0], i);
 134 }