This is an archive of the discontinued LLVM Phabricator instance.

Differential D135581

[MemCpyOpt] Use usub_sat in processMemSetMemCpyDependence
AbandonedPublic

Authored by bjope on Oct 10 2022, 7:12 AM.

Details

Reviewers
None
Summary

Select usub_sat directly for the memset length calculation, instead
of using a cmp/sub/select pattern than InstCombine later would turn
into usub_sat.

Diff Detail

Event Timeline

bjope created this revision.Oct 10 2022, 7:12 AM
Herald added a project: Restricted Project. · View Herald TranscriptOct 10 2022, 7:12 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
bjope requested review of this revision.Oct 10 2022, 7:12 AM
Herald added a project: Restricted Project. · View Herald TranscriptOct 10 2022, 7:12 AM
Harbormaster completed remote builds in B191270: Diff 466494.Oct 10 2022, 8:15 AM
bjope added inline comments.Oct 10 2022, 2:04 PM
llvm/include/llvm/IR/IRBuilder.h
945

Looks like we do not handle this in the ConstantFolder so if LHS and RHS are constant the usub_sat will remain in the IR until we simplify this.

llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
1279

Maybe this isn't always desired. One situation I could imagine is that if for example the code is comparing DestSize and SrcSize for other reasons, then maybe the InstCombine transform is more careful and thinking that it isn't preferable to use usub_sat as we need to do the comparison anyhow.

bjope abandoned this revision.Sep 9 2023, 6:30 AM

No plan on landing this right now. So I'll abandon this idea.

Herald added a subscriber: khei4. · View Herald TranscriptSep 9 2023, 6:30 AM

Revision Contents

PathSize
llvm/
include/
llvm/
IR/
5 lines
lib/
Transforms/
Scalar/
5 lines
test/
Transforms/
MemCpyOpt/
118 lines
8 lines

Diff 466494

llvm/include/llvm/IR/IRBuilder.h

Show First 20 Lines • Show All 934 Lines • ▼ Show 20 Lines CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name); return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
} }
/// Create call to the maximum intrinsic. /// Create call to the maximum intrinsic.
CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") { CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name); return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
} }
/// Create call to the usub_sat intrinsic.
CallInst *CreateUSubSat(Value *LHS, Value *RHS, const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::usub_sat, LHS, RHS, nullptr, Name);
bjopeAuthorUnsubmitted
Done
ReplyInline Actions

Looks like we do not handle this in the ConstantFolder so if LHS and RHS are constant the usub_sat will remain in the IR until we simplify this.

bjope: Looks like we do not handle this in the ConstantFolder so if LHS and RHS are constant the…
}
/// Create a call to the arithmetic_fence intrinsic. /// Create a call to the arithmetic_fence intrinsic.
CallInst *CreateArithmeticFence(Value *Val, Type *DstType, CallInst *CreateArithmeticFence(Value *Val, Type *DstType,
const Twine &Name = "") { const Twine &Name = "") {
return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr, return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
Name); Name);
} }
/// Create a call to the vector.extract intrinsic. /// Create a call to the vector.extract intrinsic.
▲ Show 20 Lines • Show All 1,641 Lines • Show Last 20 Lines

llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp

Show First 20 Lines • Show All 1,270 Lines • ▼ Show 20 Linesbool MemCpyOptPass::processMemSetMemCpyDependence(MemCpyInst *MemCpy,
if (DestSize->getType() != SrcSize->getType()) { if (DestSize->getType() != SrcSize->getType()) {
if (DestSize->getType()->getIntegerBitWidth() > if (DestSize->getType()->getIntegerBitWidth() >
SrcSize->getType()->getIntegerBitWidth()) SrcSize->getType()->getIntegerBitWidth())
SrcSize = Builder.CreateZExt(SrcSize, DestSize->getType()); SrcSize = Builder.CreateZExt(SrcSize, DestSize->getType());
else else
DestSize = Builder.CreateZExt(DestSize, SrcSize->getType()); DestSize = Builder.CreateZExt(DestSize, SrcSize->getType());
} }
Value *Ule = Builder.CreateICmpULE(DestSize, SrcSize); Value *MemsetLen = Builder.CreateUSubSat(DestSize, SrcSize, "memset.len");
bjopeAuthorUnsubmitted
Done
ReplyInline Actions

Maybe this isn't always desired. One situation I could imagine is that if for example the code is comparing DestSize and SrcSize for other reasons, then maybe the InstCombine transform is more careful and thinking that it isn't preferable to use usub_sat as we need to do the comparison anyhow.

bjope: Maybe this isn't always desired. One situation I could imagine is that if for example the code…
Value *SizeDiff = Builder.CreateSub(DestSize, SrcSize);
Value *MemsetLen = Builder.CreateSelect(
Ule, ConstantInt::getNullValue(DestSize->getType()), SizeDiff);
unsigned DestAS = Dest->getType()->getPointerAddressSpace(); unsigned DestAS = Dest->getType()->getPointerAddressSpace();
Instruction *NewMemSet = Builder.CreateMemSet( Instruction *NewMemSet = Builder.CreateMemSet(
Builder.CreateGEP( Builder.CreateGEP(
Builder.getInt8Ty(), Builder.getInt8Ty(),
Builder.CreatePointerCast(Dest, Builder.getInt8PtrTy(DestAS)), Builder.CreatePointerCast(Dest, Builder.getInt8PtrTy(DestAS)),
SrcSize), SrcSize),
MemSet->getOperand(1), MemsetLen, Alignment); MemSet->getOperand(1), MemsetLen, Alignment);
▲ Show 20 Lines • Show All 424 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/memset-memcpy-redundant-memset.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -memcpyopt -S %s -verify-memoryssa | FileCheck %s ; RUN: opt -memcpyopt -S %s -verify-memoryssa | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
@C = external constant [0 x i8] @C = external constant [0 x i8]
define void @test_constant(i64 %src_size, ptr %dst, i64 %dst_size, i8 %c) { define void @test_constant(i64 %src_size, ptr %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_constant( ; CHECK-LABEL: @test_constant(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr @C, i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr @C, i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr @C, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr @C, i64 %src_size, i1 false)
ret void ret void
} }
define void @test(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) { define void @test(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
define void @test_different_types_i32_i64(ptr noalias %dst, ptr %src, i32 %dst_size, i64 %src_size, i8 %c) { define void @test_different_types_i32_i64(ptr noalias %dst, ptr %src, i32 %dst_size, i64 %src_size, i8 %c) {
; CHECK-LABEL: @test_different_types_i32_i64( ; CHECK-LABEL: @test_different_types_i32_i64(
; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[DST_SIZE:%.*]] to i64 ; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[DST_SIZE:%.*]] to i64
; CHECK-NEXT: [[TMP2:%.*]] = icmp ule i64 [[TMP1]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[TMP1]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP3:%.*]] = sub i64 [[TMP1]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], i64 0, i64 [[TMP3]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP2]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP5]], i8 [[C:%.*]], i64 [[TMP4]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i32(ptr %dst, i8 %c, i32 %dst_size, i1 false) call void @llvm.memset.p0.i32(ptr %dst, i8 %c, i32 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
define void @test_different_types_i128_i32(ptr noalias %dst, ptr %src, i128 %dst_size, i32 %src_size, i8 %c) { define void @test_different_types_i128_i32(ptr noalias %dst, ptr %src, i128 %dst_size, i32 %src_size, i8 %c) {
; CHECK-LABEL: @test_different_types_i128_i32( ; CHECK-LABEL: @test_different_types_i128_i32(
; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[SRC_SIZE:%.*]] to i128 ; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[SRC_SIZE:%.*]] to i128
; CHECK-NEXT: [[TMP2:%.*]] = icmp ule i128 [[DST_SIZE:%.*]], [[TMP1]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i128 @llvm.usub.sat.i128(i128 [[DST_SIZE:%.*]], i128 [[TMP1]])
; CHECK-NEXT: [[TMP3:%.*]] = sub i128 [[DST_SIZE]], [[TMP1]] ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[DST:%.*]], i128 [[TMP1]]
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], i128 0, i128 [[TMP3]] ; CHECK-NEXT: call void @llvm.memset.p0.i128(ptr align 1 [[TMP2]], i8 [[C:%.*]], i128 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr [[DST:%.*]], i128 [[TMP1]]
; CHECK-NEXT: call void @llvm.memset.p0.i128(ptr align 1 [[TMP5]], i8 [[C:%.*]], i128 [[TMP4]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST]], ptr [[SRC:%.*]], i32 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST]], ptr [[SRC:%.*]], i32 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i128(ptr %dst, i8 %c, i128 %dst_size, i1 false) call void @llvm.memset.p0.i128(ptr %dst, i8 %c, i128 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %src, i32 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %src, i32 %src_size, i1 false)
ret void ret void
} }
define void @test_different_types_i32_i128(ptr noalias %dst, ptr %src, i32 %dst_size, i128 %src_size, i8 %c) { define void @test_different_types_i32_i128(ptr noalias %dst, ptr %src, i32 %dst_size, i128 %src_size, i8 %c) {
; CHECK-LABEL: @test_different_types_i32_i128( ; CHECK-LABEL: @test_different_types_i32_i128(
; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[DST_SIZE:%.*]] to i128 ; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[DST_SIZE:%.*]] to i128
; CHECK-NEXT: [[TMP2:%.*]] = icmp ule i128 [[TMP1]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i128 @llvm.usub.sat.i128(i128 [[TMP1]], i128 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP3:%.*]] = sub i128 [[TMP1]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[DST:%.*]], i128 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], i128 0, i128 [[TMP3]] ; CHECK-NEXT: call void @llvm.memset.p0.i128(ptr align 1 [[TMP2]], i8 [[C:%.*]], i128 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr [[DST:%.*]], i128 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i128(ptr align 1 [[TMP5]], i8 [[C:%.*]], i128 [[TMP4]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i128(ptr [[DST]], ptr [[SRC:%.*]], i128 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i128(ptr [[DST]], ptr [[SRC:%.*]], i128 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i32(ptr %dst, i8 %c, i32 %dst_size, i1 false) call void @llvm.memset.p0.i32(ptr %dst, i8 %c, i32 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i128(ptr %dst, ptr %src, i128 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i128(ptr %dst, ptr %src, i128 %src_size, i1 false)
ret void ret void
} }
define void @test_different_types_i64_i32(ptr noalias %dst, ptr %src, i64 %dst_size, i32 %src_size, i8 %c) { define void @test_different_types_i64_i32(ptr noalias %dst, ptr %src, i64 %dst_size, i32 %src_size, i8 %c) {
; CHECK-LABEL: @test_different_types_i64_i32( ; CHECK-LABEL: @test_different_types_i64_i32(
; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[SRC_SIZE:%.*]] to i64 ; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[SRC_SIZE:%.*]] to i64
; CHECK-NEXT: [[TMP2:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[TMP1]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[TMP1]])
; CHECK-NEXT: [[TMP3:%.*]] = sub i64 [[DST_SIZE]], [[TMP1]] ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[TMP1]]
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], i64 0, i64 [[TMP3]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP2]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[TMP1]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP5]], i8 [[C:%.*]], i64 [[TMP4]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST]], ptr [[SRC:%.*]], i32 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr [[DST]], ptr [[SRC:%.*]], i32 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %src, i32 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr %dst, ptr %src, i32 %src_size, i1 false)
ret void ret void
} }
define void @test_align_same(ptr %src, ptr noalias %dst, i64 %dst_size) { define void @test_align_same(ptr %src, ptr noalias %dst, i64 %dst_size) {
; CHECK-LABEL: @test_align_same( ; CHECK-LABEL: @test_align_same(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], 80 ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 80)
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], 80 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 80
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[TMP1]], i8 0, i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 80
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[TMP4]], i8 0, i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 80, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 80, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr align 8 %dst, i8 0, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr align 8 %dst, i8 0, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 80, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 80, i1 false)
ret void ret void
} }
define void @test_align_min(ptr %src, ptr noalias %dst, i64 %dst_size) { define void @test_align_min(ptr %src, ptr noalias %dst, i64 %dst_size) {
; CHECK-LABEL: @test_align_min( ; CHECK-LABEL: @test_align_min(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], 36 ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 36)
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], 36 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 36
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[TMP1]], i8 0, i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 36
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[TMP4]], i8 0, i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 36, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 36, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr align 8 %dst, i8 0, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr align 8 %dst, i8 0, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 36, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 36, i1 false)
ret void ret void
} }
define void @test_align_memcpy(ptr %src, ptr noalias %dst, i64 %dst_size) { define void @test_align_memcpy(ptr %src, ptr noalias %dst, i64 %dst_size) {
; CHECK-LABEL: @test_align_memcpy( ; CHECK-LABEL: @test_align_memcpy(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], 80 ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 80)
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], 80 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 80
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[TMP1]], i8 0, i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 80
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[TMP4]], i8 0, i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DST]], ptr align 8 [[SRC:%.*]], i64 80, i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[DST]], ptr align 8 [[SRC:%.*]], i64 80, i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 0, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 0, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr align 8 %dst, ptr align 8 %src, i64 80, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr align 8 %dst, ptr align 8 %src, i64 80, i1 false)
ret void ret void
} }
define void @test_non_i8_dst_type(ptr %src, i64 %src_size, ptr noalias %dst_pi64, i64 %dst_size, i8 %c) { define void @test_non_i8_dst_type(ptr %src, i64 %src_size, ptr noalias %dst_pi64, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_non_i8_dst_type( ; CHECK-LABEL: @test_non_i8_dst_type(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST_PI64:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST_PI64:%.*]], i64 [[SRC_SIZE]] ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST_PI64]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST_PI64:%.*]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst_pi64, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst_pi64, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst_pi64, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst_pi64, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
define void @test_different_dst(ptr noalias %dst2, ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size) { define void @test_different_dst(ptr noalias %dst2, ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size) {
Show All 39 Lines;
store i8 1, ptr %a1 store i8 1, ptr %a1
call void @llvm.memcpy.p0.p0.i64(ptr %a, ptr %b, i64 8, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %a, ptr %b, i64 8, i1 false)
ret void ret void
} }
define void @test_throwing_call(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) { define void @test_throwing_call(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_throwing_call( ; CHECK-LABEL: @test_throwing_call(
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr [[DST:%.*]], i8 [[C:%.*]], i64 [[DST_SIZE:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr [[DST:%.*]], i8 [[C:%.*]], i64 [[DST_SIZE:%.*]], i1 false)
; CHECK-NEXT: call void @call() #[[ATTR2:[0-9]+]] ; CHECK-NEXT: call void @call() #[[ATTR3:[0-9]+]]
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE:%.*]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @call() readnone call void @call() readnone
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
define void @test_throwing_call_alloca(ptr %src, i64 %src_size, i64 %dst_size, i8 %c) { define void @test_throwing_call_alloca(ptr %src, i64 %src_size, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_throwing_call_alloca( ; CHECK-LABEL: @test_throwing_call_alloca(
; CHECK-NEXT: [[DST:%.*]] = alloca i8, align 1 ; CHECK-NEXT: [[DST:%.*]] = alloca i8, align 1
; CHECK-NEXT: call void @call() #[[ATTR2]] ; CHECK-NEXT: call void @call() #[[ATTR3]]
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%dst = alloca i8 %dst = alloca i8
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @call() readnone call void @call() readnone
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false)
ret void ret void
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines;
call void @llvm.memcpy.p0.p0.i64(ptr %gep2, ptr %src, i64 16, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %gep2, ptr %src, i64 16, i1 false)
ret void ret void
} }
define void @test_must_alias_different_size(ptr noalias %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) { define void @test_must_alias_different_size(ptr noalias %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_must_alias_different_size( ; CHECK-LABEL: @test_must_alias_different_size(
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 16 ; CHECK-NEXT: [[GEP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 16
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i8, ptr [[DST]], i64 16 ; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i8, ptr [[DST]], i64 16
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[GEP2]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[GEP2]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[GEP2]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[GEP2]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%gep1 = getelementptr i8, ptr %dst, i64 16 %gep1 = getelementptr i8, ptr %dst, i64 16
call void @llvm.memset.p0.i64(ptr %gep1, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %gep1, i8 %c, i64 %dst_size, i1 false)
%gep2 = getelementptr i8, ptr %dst, i64 16 %gep2 = getelementptr i8, ptr %dst, i64 16
call void @llvm.memcpy.p0.p0.i64(ptr %gep2, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %gep2, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
define void @test_weird_element_type(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) { define void @test_weird_element_type(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_weird_element_type( ; CHECK-LABEL: @test_weird_element_type(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP5]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
define void @test_addrspace(ptr addrspace(1) %src, i64 %src_size, ptr addrspace(1) noalias %dst, i64 %dst_size, i8 %c) { define void @test_addrspace(ptr addrspace(1) %src, i64 %src_size, ptr addrspace(1) noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_addrspace( ; CHECK-LABEL: @test_addrspace(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr addrspace(1) [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p1.i64(ptr addrspace(1) align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr addrspace(1) [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p1.i64(ptr addrspace(1) align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p1.p1.i64(ptr addrspace(1) [[DST]], ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p1.p1.i64(ptr addrspace(1) [[DST]], ptr addrspace(1) [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p1.i64(ptr addrspace(1) %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p1.i64(ptr addrspace(1) %dst, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p1.p1.i64(ptr addrspace(1) %dst, ptr addrspace(1) %src, i64 %src_size, i1 false) call void @llvm.memcpy.p1.p1.i64(ptr addrspace(1) %dst, ptr addrspace(1) %src, i64 %src_size, i1 false)
ret void ret void
} }
Show All 9 Lines

llvm/test/Transforms/MemCpyOpt/opaque-ptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -memcpyopt -S %s -verify-memoryssa -opaque-pointers | FileCheck %s ; RUN: opt -memcpyopt -S %s -verify-memoryssa -opaque-pointers | FileCheck %s
define void @test_memset_memcpy(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) { define void @test_memset_memcpy(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_memset_memcpy( ; CHECK-LABEL: @test_memset_memcpy(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[MEMSET_LEN:%.*]] = call i64 @llvm.usub.sat.i64(i64 [[DST_SIZE:%.*]], i64 [[SRC_SIZE:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP1]], i8 [[C:%.*]], i64 [[MEMSET_LEN]], i1 false)
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false) ; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[DST]], ptr [[SRC:%.*]], i64 [[SRC_SIZE]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false) call void @llvm.memset.p0.i64(ptr %dst, i8 %c, i64 %dst_size, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false) call void @llvm.memcpy.p0.p0.i64(ptr %dst, ptr %src, i64 %src_size, i1 false)
ret void ret void
} }
Show All 40 Lines