1 //===-- ARMSelectionDAGInfo.cpp - ARM SelectionDAG Info -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the ARMSelectionDAGInfo class.
12 //===----------------------------------------------------------------------===//
14 #include "ARMTargetMachine.h"
15 #include "llvm/CodeGen/SelectionDAG.h"
16 #include "llvm/IR/DerivedTypes.h"
19 #define DEBUG_TYPE "arm-selectiondag-info"
21 ARMSelectionDAGInfo::ARMSelectionDAGInfo(const DataLayout &DL)
22 : TargetSelectionDAGInfo(&DL) {}
24 ARMSelectionDAGInfo::~ARMSelectionDAGInfo() {
27 // Emit, if possible, a specialized version of the given Libcall. Typically this
28 // means selecting the appropriately aligned version, but we also convert memset
30 SDValue ARMSelectionDAGInfo::
31 EmitSpecializedLibcall(SelectionDAG &DAG, SDLoc dl,
33 SDValue Dst, SDValue Src,
34 SDValue Size, unsigned Align,
35 RTLIB::Libcall LC) const {
36 const ARMSubtarget &Subtarget =
37 DAG.getMachineFunction().getSubtarget<ARMSubtarget>();
38 const ARMTargetLowering *TLI = Subtarget.getTargetLowering();
40 // Only use a specialized AEABI function if the default version of this
41 // Libcall is an AEABI function.
42 if (std::strncmp(TLI->getLibcallName(LC), "__aeabi", 7) != 0)
45 // Translate RTLIB::Libcall to AEABILibcall. We only do this in order to be
46 // able to translate memset to memclr and use the value to index the function
56 AEABILibcall = AEABI_MEMCPY;
59 AEABILibcall = AEABI_MEMMOVE;
62 AEABILibcall = AEABI_MEMSET;
63 if (ConstantSDNode *ConstantSrc = dyn_cast<ConstantSDNode>(Src))
64 if (ConstantSrc->getZExtValue() == 0)
65 AEABILibcall = AEABI_MEMCLR;
71 // Choose the most-aligned libcall variant that we can
78 AlignVariant = ALIGN8;
79 else if ((Align & 3) == 0)
80 AlignVariant = ALIGN4;
82 AlignVariant = ALIGN1;
84 TargetLowering::ArgListTy Args;
85 TargetLowering::ArgListEntry Entry;
86 Entry.Ty = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
88 Args.push_back(Entry);
89 if (AEABILibcall == AEABI_MEMCLR) {
91 Args.push_back(Entry);
92 } else if (AEABILibcall == AEABI_MEMSET) {
93 // Adjust parameters for memset, EABI uses format (ptr, size, value),
94 // GNU library uses (ptr, value, size)
95 // See RTABI section 4.3.4
97 Args.push_back(Entry);
99 // Extend or truncate the argument to be an i32 value for the call.
100 if (Src.getValueType().bitsGT(MVT::i32))
101 Src = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src);
102 else if (Src.getValueType().bitsLT(MVT::i32))
103 Src = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Src);
106 Entry.Ty = Type::getInt32Ty(*DAG.getContext());
107 Entry.isSExt = false;
108 Args.push_back(Entry);
111 Args.push_back(Entry);
114 Args.push_back(Entry);
117 char const *FunctionNames[4][3] = {
118 { "__aeabi_memcpy", "__aeabi_memcpy4", "__aeabi_memcpy8" },
119 { "__aeabi_memmove", "__aeabi_memmove4", "__aeabi_memmove8" },
120 { "__aeabi_memset", "__aeabi_memset4", "__aeabi_memset8" },
121 { "__aeabi_memclr", "__aeabi_memclr4", "__aeabi_memclr8" }
123 TargetLowering::CallLoweringInfo CLI(DAG);
127 TLI->getLibcallCallingConv(LC), Type::getVoidTy(*DAG.getContext()),
128 DAG.getExternalSymbol(FunctionNames[AEABILibcall][AlignVariant],
129 TLI->getPointerTy(DAG.getDataLayout())),
132 std::pair<SDValue,SDValue> CallResult = TLI->LowerCallTo(CLI);
134 return CallResult.second;
138 ARMSelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
140 SDValue Dst, SDValue Src,
141 SDValue Size, unsigned Align,
142 bool isVolatile, bool AlwaysInline,
143 MachinePointerInfo DstPtrInfo,
144 MachinePointerInfo SrcPtrInfo) const {
145 const ARMSubtarget &Subtarget =
146 DAG.getMachineFunction().getSubtarget<ARMSubtarget>();
147 // Do repeated 4-byte loads and stores. To be improved.
148 // This requires 4-byte alignment.
149 if ((Align & 3) != 0)
151 // This requires the copy size to be a constant, preferably
152 // within a subtarget-specific limit.
153 ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
155 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,
157 uint64_t SizeVal = ConstantSize->getZExtValue();
158 if (!AlwaysInline && SizeVal > Subtarget.getMaxInlineSizeThreshold())
159 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,
162 unsigned BytesLeft = SizeVal & 3;
163 unsigned NumMemOps = SizeVal >> 2;
164 unsigned EmittedNumMemOps = 0;
168 // Emit a maximum of 4 loads in Thumb1 since we have fewer registers
169 const unsigned MAX_LOADS_IN_LDM = Subtarget.isThumb1Only() ? 4 : 6;
172 uint64_t SrcOff = 0, DstOff = 0;
174 // Emit up to MAX_LOADS_IN_LDM loads, then a TokenFactor barrier, then the
175 // same number of stores. The loads and stores will get combined into
177 while (EmittedNumMemOps < NumMemOps) {
179 i < MAX_LOADS_IN_LDM && EmittedNumMemOps + i < NumMemOps; ++i) {
180 Loads[i] = DAG.getLoad(VT, dl, Chain,
181 DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
182 DAG.getConstant(SrcOff, dl, MVT::i32)),
183 SrcPtrInfo.getWithOffset(SrcOff), isVolatile,
185 TFOps[i] = Loads[i].getValue(1);
188 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
189 makeArrayRef(TFOps, i));
192 i < MAX_LOADS_IN_LDM && EmittedNumMemOps + i < NumMemOps; ++i) {
193 TFOps[i] = DAG.getStore(Chain, dl, Loads[i],
194 DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
195 DAG.getConstant(DstOff, dl, MVT::i32)),
196 DstPtrInfo.getWithOffset(DstOff),
197 isVolatile, false, 0);
200 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
201 makeArrayRef(TFOps, i));
203 EmittedNumMemOps += i;
209 // Issue loads / stores for the trailing (1 - 3) bytes.
210 unsigned BytesLeftSave = BytesLeft;
213 if (BytesLeft >= 2) {
221 Loads[i] = DAG.getLoad(VT, dl, Chain,
222 DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
223 DAG.getConstant(SrcOff, dl, MVT::i32)),
224 SrcPtrInfo.getWithOffset(SrcOff),
225 false, false, false, 0);
226 TFOps[i] = Loads[i].getValue(1);
231 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
232 makeArrayRef(TFOps, i));
235 BytesLeft = BytesLeftSave;
237 if (BytesLeft >= 2) {
245 TFOps[i] = DAG.getStore(Chain, dl, Loads[i],
246 DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
247 DAG.getConstant(DstOff, dl, MVT::i32)),
248 DstPtrInfo.getWithOffset(DstOff), false, false, 0);
253 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
254 makeArrayRef(TFOps, i));
258 SDValue ARMSelectionDAGInfo::
259 EmitTargetCodeForMemmove(SelectionDAG &DAG, SDLoc dl,
261 SDValue Dst, SDValue Src,
262 SDValue Size, unsigned Align,
264 MachinePointerInfo DstPtrInfo,
265 MachinePointerInfo SrcPtrInfo) const {
266 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,
271 SDValue ARMSelectionDAGInfo::
272 EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
273 SDValue Chain, SDValue Dst,
274 SDValue Src, SDValue Size,
275 unsigned Align, bool isVolatile,
276 MachinePointerInfo DstPtrInfo) const {
277 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,