This is an archive of the discontinued LLVM Phabricator instance.

Differential D95278

[InstCombine] remove incompatible attribute when simplifying some lib calls
ClosedPublic

Authored by zequanwu on Jan 22 2021, 5:14 PM.

Details

Reviewers
jdoerfert
spatel
xbolva00
fhahn
sstefan1
uenoku
baziotis
Commits
rG867bdfeff178: [InstCombine] remove incompatible attribute when simplifying some lib calls
Summary

I try to enable attributor module pass to build chrome, and found another crash
(crbug.com/1166273). So, we might want to do the same as D95088 to remove
incompatible attribute in more lib calls.

Diff Detail

Event Timeline

zequanwu created this revision.Jan 22 2021, 5:14 PM
Herald added a subscriber: hiraditya. · View Herald TranscriptJan 22 2021, 5:14 PM
zequanwu requested review of this revision.Jan 22 2021, 5:14 PM
Herald added a project: Restricted Project. · View Herald TranscriptJan 22 2021, 5:14 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
jdoerfert accepted this revision.Jan 22 2021, 5:16 PM

LGTM. Thanks for following up on this!

llvm/test/Transforms/InstCombine/strncpy-1.ll
184

newline.

This revision is now accepted and ready to land.Jan 22 2021, 5:16 PM
zequanwu edited the summary of this revision. (Show Details)Jan 22 2021, 5:18 PM
Herald added a reviewer: sstefan1. · View Herald TranscriptJan 22 2021, 5:18 PM
Herald added a reviewer: uenoku. · View Herald Transcript
Herald added a reviewer: baziotis. · View Herald Transcript
Herald added a subscriber: uenoku. · View Herald Transcript
This revision was landed with ongoing or failed builds.Jan 22 2021, 5:28 PM
Closed by commit rG867bdfeff178: [InstCombine] remove incompatible attribute when simplifying some lib calls (authored by zequanwu). · Explain Why
This revision was automatically updated to reflect the committed changes.
zequanwu added a commit: rG867bdfeff178: [InstCombine] remove incompatible attribute when simplifying some lib calls.
Harbormaster completed remote builds in B86375: Diff 318698.Jan 22 2021, 5:59 PM

Revision Contents

PathSize
llvm/
lib/
Transforms/
Utils/
21 lines
test/
Transforms/
InstCombine/
9 lines
11 lines
8 lines
12 lines
9 lines
11 lines
13 lines
12 lines
12 lines

Diff 318703

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 535 Lines • ▼ Show 20 Lines else
return nullptr; return nullptr;
// We have enough information to now generate the memcpy call to do the // We have enough information to now generate the memcpy call to do the
// copy for us. Make a memcpy to copy the nul byte with align = 1. // copy for us. Make a memcpy to copy the nul byte with align = 1.
CallInst *NewCI = CallInst *NewCI =
B.CreateMemCpy(Dst, Align(1), Src, Align(1), B.CreateMemCpy(Dst, Align(1), Src, Align(1),
ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len)); ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len));
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return Dst; return Dst;
} }
Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1); Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
if (Dst == Src) { // stpcpy(x,x) -> x+strlen(x) if (Dst == Src) { // stpcpy(x,x) -> x+strlen(x)
Value *StrLen = emitStrLen(Src, B, DL, TLI); Value *StrLen = emitStrLen(Src, B, DL, TLI);
Show All 11 LinesValue *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len); Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
Value *DstEnd = B.CreateGEP(B.getInt8Ty(), Dst, Value *DstEnd = B.CreateGEP(B.getInt8Ty(), Dst,
ConstantInt::get(DL.getIntPtrType(PT), Len - 1)); ConstantInt::get(DL.getIntPtrType(PT), Len - 1));
// We have enough information to now generate the memcpy call to do the // We have enough information to now generate the memcpy call to do the
// copy for us. Make a memcpy to copy the nul byte with align = 1. // copy for us. Make a memcpy to copy the nul byte with align = 1.
CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), LenV); CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), LenV);
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return DstEnd; return DstEnd;
} }
Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
Value *Dst = CI->getArgOperand(0); Value *Dst = CI->getArgOperand(0);
Value *Src = CI->getArgOperand(1); Value *Src = CI->getArgOperand(1);
Value *Size = CI->getArgOperand(2); Value *Size = CI->getArgOperand(2);
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines if (Len > SrcLen + 1) {
} }
} }
Type *PT = Callee->getFunctionType()->getParamType(0); Type *PT = Callee->getFunctionType()->getParamType(0);
// strncpy(x, s, c) -> memcpy(align 1 x, align 1 s, c) [s and c are constant] // strncpy(x, s, c) -> memcpy(align 1 x, align 1 s, c) [s and c are constant]
CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1),
ConstantInt::get(DL.getIntPtrType(PT), Len)); ConstantInt::get(DL.getIntPtrType(PT), Len));
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return Dst; return Dst;
} }
Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B, Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B,
unsigned CharSize) { unsigned CharSize) {
Value *Src = CI->getArgOperand(0); Value *Src = CI->getArgOperand(0);
// Constant folding: strlen("xyz") -> 3 // Constant folding: strlen("xyz") -> 3
▲ Show 20 Lines • Show All 459 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL); annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
if (isa<IntrinsicInst>(CI)) if (isa<IntrinsicInst>(CI))
return nullptr; return nullptr;
// memcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n) // memcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n)
CallInst *NewCI = B.CreateMemCpy(CI->getArgOperand(0), Align(1), CallInst *NewCI = B.CreateMemCpy(CI->getArgOperand(0), Align(1),
CI->getArgOperand(1), Align(1), Size); CI->getArgOperand(1), Align(1), Size);
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
Value *LibCallSimplifier::optimizeMemCCpy(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeMemCCpy(CallInst *CI, IRBuilderBase &B) {
Value *Dst = CI->getArgOperand(0); Value *Dst = CI->getArgOperand(0);
Value *Src = CI->getArgOperand(1); Value *Src = CI->getArgOperand(1);
ConstantInt *StopChar = dyn_cast<ConstantInt>(CI->getArgOperand(2)); ConstantInt *StopChar = dyn_cast<ConstantInt>(CI->getArgOperand(2));
ConstantInt *N = dyn_cast<ConstantInt>(CI->getArgOperand(3)); ConstantInt *N = dyn_cast<ConstantInt>(CI->getArgOperand(3));
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilderBase &B) {
annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL); annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
if (isa<IntrinsicInst>(CI)) if (isa<IntrinsicInst>(CI))
return nullptr; return nullptr;
// memmove(x, y, n) -> llvm.memmove(align 1 x, align 1 y, n) // memmove(x, y, n) -> llvm.memmove(align 1 x, align 1 y, n)
CallInst *NewCI = B.CreateMemMove(CI->getArgOperand(0), Align(1), CallInst *NewCI = B.CreateMemMove(CI->getArgOperand(0), Align(1),
CI->getArgOperand(1), Align(1), Size); CI->getArgOperand(1), Align(1), Size);
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
/// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n). /// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n).
Value *LibCallSimplifier::foldMallocMemset(CallInst *Memset, IRBuilderBase &B) { Value *LibCallSimplifier::foldMallocMemset(CallInst *Memset, IRBuilderBase &B) {
// This has to be a memset of zeros (bzero). // This has to be a memset of zeros (bzero).
auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1)); auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
if (!FillValue || FillValue->getZExtValue() != 0) if (!FillValue || FillValue->getZExtValue() != 0)
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) {
if (auto *Calloc = foldMallocMemset(CI, B)) if (auto *Calloc = foldMallocMemset(CI, B))
return Calloc; return Calloc;
// memset(p, v, n) -> llvm.memset(align 1 p, v, n) // memset(p, v, n) -> llvm.memset(align 1 p, v, n)
Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false); Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1)); CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1));
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) {
if (isa<ConstantPointerNull>(CI->getArgOperand(0))) if (isa<ConstantPointerNull>(CI->getArgOperand(0)))
return emitMalloc(CI->getArgOperand(1), B, DL, TLI); return emitMalloc(CI->getArgOperand(1), B, DL, TLI);
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 2,021 Lines • ▼ Show 20 Lines
Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
IRBuilderBase &B) { IRBuilderBase &B) {
if (isFortifiedCallFoldable(CI, 3, 2)) { if (isFortifiedCallFoldable(CI, 3, 2)) {
CallInst *NewCI = CallInst *NewCI =
B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(1), B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
Align(1), CI->getArgOperand(2)); Align(1), CI->getArgOperand(2));
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
return nullptr; return nullptr;
} }
Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
IRBuilderBase &B) { IRBuilderBase &B) {
if (isFortifiedCallFoldable(CI, 3, 2)) { if (isFortifiedCallFoldable(CI, 3, 2)) {
CallInst *NewCI = CallInst *NewCI =
B.CreateMemMove(CI->getArgOperand(0), Align(1), CI->getArgOperand(1), B.CreateMemMove(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
Align(1), CI->getArgOperand(2)); Align(1), CI->getArgOperand(2));
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
return nullptr; return nullptr;
} }
Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
IRBuilderBase &B) { IRBuilderBase &B) {
// TODO: Try foldMallocMemset() here. // TODO: Try foldMallocMemset() here.
if (isFortifiedCallFoldable(CI, 3, 2)) { if (isFortifiedCallFoldable(CI, 3, 2)) {
Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false); Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val,
CI->getArgOperand(2), Align(1)); CI->getArgOperand(2), Align(1));
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
return nullptr; return nullptr;
} }
Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(CallInst *CI,
IRBuilderBase &B) { IRBuilderBase &B) {
const DataLayout &DL = CI->getModule()->getDataLayout(); const DataLayout &DL = CI->getModule()->getDataLayout();
if (isFortifiedCallFoldable(CI, 3, 2)) if (isFortifiedCallFoldable(CI, 3, 2))
if (Value *Call = emitMemPCpy(CI->getArgOperand(0), CI->getArgOperand(1), if (Value *Call = emitMemPCpy(CI->getArgOperand(0), CI->getArgOperand(1),
CI->getArgOperand(2), B, DL, TLI)) { CI->getArgOperand(2), B, DL, TLI)) {
CallInst *NewCI = cast<CallInst>(Call); CallInst *NewCI = cast<CallInst>(Call);
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(
AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
return NewCI; return NewCI;
} }
return nullptr; return nullptr;
} }
Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI, Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
IRBuilderBase &B, IRBuilderBase &B,
LibFunc Func) { LibFunc Func) {
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/memcpy-1.ll

Show All 22 Lines
define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) strictfp { define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) strictfp {
; CHECK-LABEL: @test_simplify2( ; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[MEM1]] ; CHECK-NEXT: ret i8* [[MEM1]]
; ;
%ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size) strictfp %ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size) strictfp
ret i8* %ret ret i8* %ret
} }
define i8* @test_no_incompatible_attr(i8* %mem1, i8* %mem2, i32 %size) {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[MEM1]]
%ret = call dereferenceable(1) i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size)
ret i8* %ret
}

llvm/test/Transforms/InstCombine/memcpy_chk-1.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret i8* [[DST]] ; CHECK-NEXT: ret i8* [[DST]]
; ;
%src = bitcast %struct.T2* @t2 to i8* %src = bitcast %struct.T2* @t2 to i8*
%dst = call i8* %alloc() %dst = call i8* %alloc()
%ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824) %ret = call i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824)
ret i8* %ret ret i8* %ret
} }
define i8* @test_no_incompatible_attr(i8* %mem, i32 %val, i32 %size) {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 4 dereferenceable(1824) bitcast (%struct.T1* @t1 to i8*), i8* nonnull align 4 dereferenceable(1824) bitcast (%struct.T2* @t2 to i8*), i64 1824, i1 false)
; CHECK-NEXT: ret i8* bitcast (%struct.T1* @t1 to i8*)
;
%dst = bitcast %struct.T1* @t1 to i8*
%src = bitcast %struct.T2* @t2 to i8*
%ret = call dereferenceable(1) i8* @__memcpy_chk(i8* %dst, i8* %src, i64 1824, i64 1824)
ret i8* %ret
}
declare i8* @__memcpy_chk(i8*, i8*, i64, i64) declare i8* @__memcpy_chk(i8*, i8*, i64, i64)

llvm/test/Transforms/InstCombine/memmove-1.ll

Show All 9 Lines
define i8* @test_simplify1(i8* %mem1, i8* %mem2, i32 %size) { define i8* @test_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
; CHECK-LABEL: @test_simplify1( ; CHECK-LABEL: @test_simplify1(
%ret = call i8* @memmove(i8* %mem1, i8* %mem2, i32 %size) %ret = call i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
; CHECK: call void @llvm.memmove ; CHECK: call void @llvm.memmove
ret i8* %ret ret i8* %ret
; CHECK: ret i8* %mem1 ; CHECK: ret i8* %mem1
} }
define i8* @test_no_incompatible_attr(i8* %mem1, i8* %mem2, i32 %size) {
; CHECK-LABEL: @test_no_incompatible_attr(
%ret = call dereferenceable(1) i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
; CHECK: call void @llvm.memmove
ret i8* %ret
; CHECK: ret i8* %mem1
}

llvm/test/Transforms/InstCombine/memmove_chk-1.ll

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
; ;
%dst = bitcast %struct.T1* @t1 to i8* %dst = bitcast %struct.T1* @t1 to i8*
%src = bitcast %struct.T2* @t2 to i8* %src = bitcast %struct.T2* @t2 to i8*
%ret = call i8* @__memmove_chk(i8* %dst, i8* %src, i64 1024, i64 0) %ret = call i8* @__memmove_chk(i8* %dst, i8* %src, i64 1024, i64 0)
ret i8* %ret ret i8* %ret
} }
define i8* @test_no_incompatible_attr(i8* %mem, i32 %val, i32 %size) {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 4 dereferenceable(1824) bitcast (%struct.T1* @t1 to i8*), i8* nonnull align 4 dereferenceable(1824) bitcast (%struct.T2* @t2 to i8*), i64 1824, i1 false)
; CHECK-NEXT: ret i8* bitcast (%struct.T1* @t1 to i8*)
;
%dst = bitcast %struct.T1* @t1 to i8*
%src = bitcast %struct.T2* @t2 to i8*
%ret = call dereferenceable(1) i8* @__memmove_chk(i8* %dst, i8* %src, i64 1824, i64 1824)
ret i8* %ret
}
declare i8* @__memmove_chk(i8*, i8*, i64, i64) declare i8* @__memmove_chk(i8*, i8*, i64, i64)

llvm/test/Transforms/InstCombine/memset-1.ll

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @memset_attrs4( ; CHECK-LABEL: @memset_attrs4(
; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* nonnull align 1 [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #0 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* nonnull align 1 [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #0
; CHECK-NEXT: ret i8* [[PTR]] ; CHECK-NEXT: ret i8* [[PTR]]
; ;
%memset = tail call i8* @memset(i8* nonnull %ptr, i32 0, i32 %size) #1 %memset = tail call i8* @memset(i8* nonnull %ptr, i32 0, i32 %size) #1
ret i8* %memset ret i8* %memset
} }
define i8* @test_no_incompatible_attr(i8* %mem, i32 %val, i32 %size) {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[MEM]]
;
%ret = call dereferenceable(1) i8* @memset(i8* %mem, i32 %val, i32 %size)
ret i8* %ret
}
attributes #0 = { nounwind ssp uwtable } attributes #0 = { nounwind ssp uwtable }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { nounwind readnone } attributes #2 = { nounwind readnone }

llvm/test/Transforms/InstCombine/memset_chk-1.ll

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linesif.end:
%call3 = tail call i8* @__memset_chk(i8* nonnull %call, i32 0, i64 %size, i64 %call2) #1 %call3 = tail call i8* @__memset_chk(i8* nonnull %call, i32 0, i64 %size, i64 %call2) #1
br label %cleanup br label %cleanup
cleanup: cleanup:
%retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ] %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ]
ret float* %retval.0 ret float* %retval.0
} }
define i8* @test_no_incompatible_attr(i8* %mem, i32 %val, i32 %size) {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 4 dereferenceable(1824) bitcast (%struct.T* @t to i8*), i8 0, i64 1824, i1 false)
; CHECK-NEXT: ret i8* bitcast (%struct.T* @t to i8*)
;
%dst = bitcast %struct.T* @t to i8*
%ret = call dereferenceable(1) i8* @__memset_chk(i8* %dst, i32 0, i64 1824, i64 1824)
ret i8* %ret
}
declare noalias i8* @malloc(i64) #1 declare noalias i8* @malloc(i64) #1
attributes #0 = { nounwind ssp uwtable } attributes #0 = { nounwind ssp uwtable }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { nounwind readnone } attributes #2 = { nounwind readnone }

llvm/test/Transforms/InstCombine/stpcpy-1.ll

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
; ;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0 %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [32 x i8], [32 x i8]* @b, i32 0, i32 0 %src = getelementptr [32 x i8], [32 x i8]* @b, i32 0, i32 0
%ret = call i8* @stpcpy(i8* %dst, i8* %src) %ret = call i8* @stpcpy(i8* %dst, i8* %src)
ret i8* %ret ret i8* %ret
} }
define i8* @test_no_incompatible_attr() {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* nonnull align 1 dereferenceable(6) getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 0), i8* nonnull align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i32 6, i1 false)
; CHECK-NEXT: ret i8* getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 5)
;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
%ret = call dereferenceable(1) i8* @stpcpy(i8* %dst, i8* %src)
ret i8* %ret
}

llvm/test/Transforms/InstCombine/strcpy-1.ll

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
; ;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0 %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [32 x i8], [32 x i8]* @b, i32 0, i32 0 %src = getelementptr [32 x i8], [32 x i8]* @b, i32 0, i32 0
%ret = call i8* @strcpy(i8* %dst, i8* %src) %ret = call i8* @strcpy(i8* %dst, i8* %src)
ret i8* %ret ret i8* %ret
} }
define void @test_no_incompatible_attr() {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* nonnull align 1 dereferenceable(6) getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 0), i8* nonnull align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i32 6, i1 false)
; CHECK-NEXT: ret void
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
call dereferenceable(1) i8* @strcpy(i8* %dst, i8* %src)
ret void
}

llvm/test/Transforms/InstCombine/strncpy-1.ll

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0 %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0 %src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
call i8* @strncpy(i8* %dst, i8* %src, i32 8) call i8* @strncpy(i8* %dst, i8* %src, i32 8)
ret void ret void
} }
define void @test_no_incompatible_attr() {
; CHECK-LABEL: @test_no_incompatible_attr(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* nonnull align 1 dereferenceable(6) getelementptr inbounds ([32 x i8], [32 x i8]* @a, i32 0, i32 0), i8* nonnull align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i32 6, i1 false)
; CHECK-NEXT: ret void
;
%dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
%src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
call i8* @strncpy(i8* %dst, i8* %src, i32 6)
ret void
}
jdoerfertUnsubmitted
Not Done
ReplyInline Actions

newline.

jdoerfert: newline.