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 // Emit, if possible, a specialized version of the given Libcall. Typically this
22 // means selecting the appropriately aligned version, but we also convert memset
24 SDValue ARMSelectionDAGInfo::
25 EmitSpecializedLibcall(SelectionDAG &DAG, SDLoc dl,
27 SDValue Dst, SDValue Src,
28 SDValue Size, unsigned Align,
29 RTLIB::Libcall LC) const {
30 const ARMSubtarget &Subtarget =
31 DAG.getMachineFunction().getSubtarget<ARMSubtarget>();
32 const ARMTargetLowering *TLI = Subtarget.getTargetLowering();
34 // Only use a specialized AEABI function if the default version of this
35 // Libcall is an AEABI function.
36 if (std::strncmp(TLI->getLibcallName(LC), "__aeabi", 7) != 0)
39 // Translate RTLIB::Libcall to AEABILibcall. We only do this in order to be
40 // able to translate memset to memclr and use the value to index the function
50 AEABILibcall = AEABI_MEMCPY;
53 AEABILibcall = AEABI_MEMMOVE;
56 AEABILibcall = AEABI_MEMSET;
57 if (ConstantSDNode *ConstantSrc = dyn_cast<ConstantSDNode>(Src))
58 if (ConstantSrc->getZExtValue() == 0)
59 AEABILibcall = AEABI_MEMCLR;
65 // Choose the most-aligned libcall variant that we can
72 AlignVariant = ALIGN8;
73 else if ((Align & 3) == 0)
74 AlignVariant = ALIGN4;
76 AlignVariant = ALIGN1;
78 TargetLowering::ArgListTy Args;
79 TargetLowering::ArgListEntry Entry;
80 Entry.Ty = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
82 Args.push_back(Entry);
83 if (AEABILibcall == AEABI_MEMCLR) {
85 Args.push_back(Entry);
86 } else if (AEABILibcall == AEABI_MEMSET) {
87 // Adjust parameters for memset, EABI uses format (ptr, size, value),
88 // GNU library uses (ptr, value, size)
89 // See RTABI section 4.3.4
91 Args.push_back(Entry);
93 // Extend or truncate the argument to be an i32 value for the call.
94 if (Src.getValueType().bitsGT(MVT::i32))
95 Src = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src);
96 else if (Src.getValueType().bitsLT(MVT::i32))
97 Src = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Src);
100 Entry.Ty = Type::getInt32Ty(*DAG.getContext());
101 Entry.isSExt = false;
102 Args.push_back(Entry);
105 Args.push_back(Entry);
108 Args.push_back(Entry);
111 char const *FunctionNames[4][3] = {
112 { "__aeabi_memcpy", "__aeabi_memcpy4", "__aeabi_memcpy8" },
113 { "__aeabi_memmove", "__aeabi_memmove4", "__aeabi_memmove8" },
114 { "__aeabi_memset", "__aeabi_memset4", "__aeabi_memset8" },
115 { "__aeabi_memclr", "__aeabi_memclr4", "__aeabi_memclr8" }
117 TargetLowering::CallLoweringInfo CLI(DAG);
121 TLI->getLibcallCallingConv(LC), Type::getVoidTy(*DAG.getContext()),
122 DAG.getExternalSymbol(FunctionNames[AEABILibcall][AlignVariant],
123 TLI->getPointerTy(DAG.getDataLayout())),
126 std::pair<SDValue,SDValue> CallResult = TLI->LowerCallTo(CLI);
128 return CallResult.second;
132 ARMSelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
134 SDValue Dst, SDValue Src,
135 SDValue Size, unsigned Align,
136 bool isVolatile, bool AlwaysInline,
137 MachinePointerInfo DstPtrInfo,
138 MachinePointerInfo SrcPtrInfo) const {
139 const ARMSubtarget &Subtarget =
140 DAG.getMachineFunction().getSubtarget<ARMSubtarget>();
141 // Do repeated 4-byte loads and stores. To be improved.
142 // This requires 4-byte alignment.
143 if ((Align & 3) != 0)
145 // This requires the copy size to be a constant, preferably
146 // within a subtarget-specific limit.
147 ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
149 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,
151 uint64_t SizeVal = ConstantSize->getZExtValue();
152 if (!AlwaysInline && SizeVal > Subtarget.getMaxInlineSizeThreshold())
153 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,
156 unsigned BytesLeft = SizeVal & 3;
157 unsigned NumMemOps = SizeVal >> 2;
158 unsigned EmittedNumMemOps = 0;
162 // Emit a maximum of 4 loads in Thumb1 since we have fewer registers
163 const unsigned MAX_LOADS_IN_LDM = Subtarget.isThumb1Only() ? 4 : 6;
166 uint64_t SrcOff = 0, DstOff = 0;
168 // Emit up to MAX_LOADS_IN_LDM loads, then a TokenFactor barrier, then the
169 // same number of stores. The loads and stores will get combined into
171 while (EmittedNumMemOps < NumMemOps) {
173 i < MAX_LOADS_IN_LDM && EmittedNumMemOps + i < NumMemOps; ++i) {
174 Loads[i] = DAG.getLoad(VT, dl, Chain,
175 DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
176 DAG.getConstant(SrcOff, dl, MVT::i32)),
177 SrcPtrInfo.getWithOffset(SrcOff), isVolatile,
179 TFOps[i] = Loads[i].getValue(1);
182 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
183 makeArrayRef(TFOps, i));
186 i < MAX_LOADS_IN_LDM && EmittedNumMemOps + i < NumMemOps; ++i) {
187 TFOps[i] = DAG.getStore(Chain, dl, Loads[i],
188 DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
189 DAG.getConstant(DstOff, dl, MVT::i32)),
190 DstPtrInfo.getWithOffset(DstOff),
191 isVolatile, false, 0);
194 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
195 makeArrayRef(TFOps, i));
197 EmittedNumMemOps += i;
203 // Issue loads / stores for the trailing (1 - 3) bytes.
204 unsigned BytesLeftSave = BytesLeft;
207 if (BytesLeft >= 2) {
215 Loads[i] = DAG.getLoad(VT, dl, Chain,
216 DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
217 DAG.getConstant(SrcOff, dl, MVT::i32)),
218 SrcPtrInfo.getWithOffset(SrcOff),
219 false, false, false, 0);
220 TFOps[i] = Loads[i].getValue(1);
225 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
226 makeArrayRef(TFOps, i));
229 BytesLeft = BytesLeftSave;
231 if (BytesLeft >= 2) {
239 TFOps[i] = DAG.getStore(Chain, dl, Loads[i],
240 DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
241 DAG.getConstant(DstOff, dl, MVT::i32)),
242 DstPtrInfo.getWithOffset(DstOff), false, false, 0);
247 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
248 makeArrayRef(TFOps, i));
252 SDValue ARMSelectionDAGInfo::
253 EmitTargetCodeForMemmove(SelectionDAG &DAG, SDLoc dl,
255 SDValue Dst, SDValue Src,
256 SDValue Size, unsigned Align,
258 MachinePointerInfo DstPtrInfo,
259 MachinePointerInfo SrcPtrInfo) const {
260 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,
265 SDValue ARMSelectionDAGInfo::
266 EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
267 SDValue Chain, SDValue Dst,
268 SDValue Src, SDValue Size,
269 unsigned Align, bool isVolatile,
270 MachinePointerInfo DstPtrInfo) const {
271 return EmitSpecializedLibcall(DAG, dl, Chain, Dst, Src, Size, Align,