bool ARMEmitStore(EVT VT, unsigned SrcReg, Address &Addr);
bool ARMComputeAddress(const Value *Obj, Address &Addr);
void ARMSimplifyAddress(Address &Addr, EVT VT, bool useAM3);
- bool ARMIsMemXferSmall(uint64_t Len);
- bool ARMTryEmitSmallMemXfer(Address Dest, Address Src, uint64_t Len,
- bool isMemCpy);
+ bool ARMIsMemCpySmall(uint64_t Len);
+ bool ARMTryEmitSmallMemCpy(Address Dest, Address Src, uint64_t Len);
unsigned ARMEmitIntExt(EVT SrcVT, unsigned SrcReg, EVT DestVT, bool isZExt);
unsigned ARMMaterializeFP(const ConstantFP *CFP, EVT VT);
unsigned ARMMaterializeInt(const Constant *C, EVT VT);
return true;
}
-bool ARMFastISel::ARMIsMemXferSmall(uint64_t Len) {
+bool ARMFastISel::ARMIsMemCpySmall(uint64_t Len) {
return Len <= 16;
}
-bool ARMFastISel::ARMTryEmitSmallMemXfer(Address Dest, Address Src, uint64_t Len,
- bool isMemCpy) {
- // FIXME: Memmove's require a little more care because their source and
- // destination may overlap.
- if (!isMemCpy)
- return false;
-
+bool ARMFastISel::ARMTryEmitSmallMemCpy(Address Dest, Address Src, uint64_t Len) {
// Make sure we don't bloat code by inlining very large memcpy's.
- if (!ARMIsMemXferSmall(Len))
+ if (!ARMIsMemCpySmall(Len))
return false;
// We don't care about alignment here since we just emit integer accesses.
// we would emit dead code because we don't currently handle memmoves.
bool isMemCpy = (I.getIntrinsicID() == Intrinsic::memcpy);
if (isa<ConstantInt>(MTI.getLength()) && isMemCpy) {
- // Small memcpy/memmove's are common enough that we want to do them
- // without a call if possible.
+ // Small memcpy's are common enough that we want to do them without a call
+ // if possible.
uint64_t Len = cast<ConstantInt>(MTI.getLength())->getZExtValue();
- if (ARMIsMemXferSmall(Len)) {
+ if (ARMIsMemCpySmall(Len)) {
Address Dest, Src;
if (!ARMComputeAddress(MTI.getRawDest(), Dest) ||
!ARMComputeAddress(MTI.getRawSource(), Src))
return false;
- if (ARMTryEmitSmallMemXfer(Dest, Src, Len, isMemCpy))
+ if (ARMTryEmitSmallMemCpy(Dest, Src, Len))
return true;
}
}