This is an archive of the discontinued LLVM Phabricator instance.

Differential D25776

[AliasSetTracker] Add support for memcpy and memmove.
ClosedPublic

Authored by mcrosier on Oct 19 2016, 9:58 AM.

Details

Reviewers
mkuper
haicheng
mssimpso
Commits
rG6e3a92ec880b: [AliasSetTracker] Add support for memcpy and memmove.
rL284630: [AliasSetTracker] Add support for memcpy and memmove.
Summary

Please take a look.

Chad

Diff Detail

Repository
rL LLVM

Event Timeline

mcrosier updated this revision to Diff 75164.Oct 19 2016, 9:58 AM
mcrosier retitled this revision from to [AliasSetTracker] Add support for memcpy and memmove..
mcrosier updated this object.
mcrosier added reviewers: haicheng, mkuper, mssimpso.
mcrosier added a subscriber: llvm-commits.
mcrosier added a parent revision: D25748: [AliasSetTracker] Return void for add() functions. NFC..Oct 19 2016, 10:00 AM
mkuper accepted this revision.Oct 19 2016, 11:48 AM
mkuper edited edge metadata.

LGTM

This revision is now accepted and ready to land.Oct 19 2016, 11:48 AM
Closed by commit rL284630: [AliasSetTracker] Add support for memcpy and memmove. (authored by mcrosier). · Explain WhyOct 19 2016, 12:18 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Analysis/
1 line
lib/
Analysis/
24 lines
test/
Analysis/
AliasSet/
114 lines

Diff 75195

llvm/trunk/include/llvm/Analysis/AliasSetTracker.h

Show First 20 Lines • Show All 343 Lines • ▼ Show 20 Linespublic:
/// These methods return true if inserting the instruction resulted in the /// These methods return true if inserting the instruction resulted in the
/// addition of a new alias set (i.e., the pointer did not alias anything). /// addition of a new alias set (i.e., the pointer did not alias anything).
/// ///
void add(Value *Ptr, uint64_t Size, const AAMDNodes &AAInfo); // Add a loc. void add(Value *Ptr, uint64_t Size, const AAMDNodes &AAInfo); // Add a loc.
void add(LoadInst *LI); void add(LoadInst *LI);
void add(StoreInst *SI); void add(StoreInst *SI);
void add(VAArgInst *VAAI); void add(VAArgInst *VAAI);
void add(MemSetInst *MSI); void add(MemSetInst *MSI);
void add(MemTransferInst *MTI);
void add(Instruction *I); // Dispatch to one of the other add methods... void add(Instruction *I); // Dispatch to one of the other add methods...
void add(BasicBlock &BB); // Add all instructions in basic block void add(BasicBlock &BB); // Add all instructions in basic block
void add(const AliasSetTracker &AST); // Add alias relations from another AST void add(const AliasSetTracker &AST); // Add alias relations from another AST
void addUnknown(Instruction *I); void addUnknown(Instruction *I);
void clear(); void clear();
/// Return the alias sets that are active. /// Return the alias sets that are active.
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/AliasSetTracker.cpp

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Lines else
Len = MemoryLocation::UnknownSize; Len = MemoryLocation::UnknownSize;
AliasSet &AS = AliasSet &AS =
addPointer(MSI->getRawDest(), Len, AAInfo, AliasSet::ModAccess); addPointer(MSI->getRawDest(), Len, AAInfo, AliasSet::ModAccess);
if (MSI->isVolatile()) if (MSI->isVolatile())
AS.setVolatile(); AS.setVolatile();
} }
void AliasSetTracker::add(MemTransferInst *MTI) {
AAMDNodes AAInfo;
MTI->getAAMetadata(AAInfo);
uint64_t Len;
if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
Len = C->getZExtValue();
else
Len = MemoryLocation::UnknownSize;
AliasSet &ASSrc =
addPointer(MTI->getRawSource(), Len, AAInfo, AliasSet::RefAccess);
if (MTI->isVolatile())
ASSrc.setVolatile();
AliasSet &ASDst =
addPointer(MTI->getRawDest(), Len, AAInfo, AliasSet::ModAccess);
if (MTI->isVolatile())
ASDst.setVolatile();
}
void AliasSetTracker::addUnknown(Instruction *Inst) { void AliasSetTracker::addUnknown(Instruction *Inst) {
if (isa<DbgInfoIntrinsic>(Inst)) if (isa<DbgInfoIntrinsic>(Inst))
return; // Ignore DbgInfo Intrinsics. return; // Ignore DbgInfo Intrinsics.
if (!Inst->mayReadOrWriteMemory()) if (!Inst->mayReadOrWriteMemory())
return; // doesn't alias anything return; // doesn't alias anything
AliasSet *AS = findAliasSetForUnknownInst(Inst); AliasSet *AS = findAliasSetForUnknownInst(Inst);
if (AS) { if (AS) {
Show All 10 Linesvoid AliasSetTracker::add(Instruction *I) {
if (LoadInst *LI = dyn_cast<LoadInst>(I)) if (LoadInst *LI = dyn_cast<LoadInst>(I))
return add(LI); return add(LI);
if (StoreInst *SI = dyn_cast<StoreInst>(I)) if (StoreInst *SI = dyn_cast<StoreInst>(I))
return add(SI); return add(SI);
if (VAArgInst *VAAI = dyn_cast<VAArgInst>(I)) if (VAArgInst *VAAI = dyn_cast<VAArgInst>(I))
return add(VAAI); return add(VAAI);
if (MemSetInst *MSI = dyn_cast<MemSetInst>(I)) if (MemSetInst *MSI = dyn_cast<MemSetInst>(I))
return add(MSI); return add(MSI);
if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(I))
return add(MTI);
return addUnknown(I); return addUnknown(I);
// FIXME: add support of memcpy and memmove.
} }
void AliasSetTracker::add(BasicBlock &BB) { void AliasSetTracker::add(BasicBlock &BB) {
for (auto &I : BB) for (auto &I : BB)
add(&I); add(&I);
} }
void AliasSetTracker::add(const AliasSetTracker &AST) { void AliasSetTracker::add(const AliasSetTracker &AST) {
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

llvm/trunk/test/Analysis/AliasSet/memtransfer.ll

; RUN: opt -basicaa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
@s = global i8 1, align 1
@d = global i8 2, align 1
; CHECK: Alias sets for function 'test1':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, 1)
; CHECK-NOT: 1 Unknown instructions
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %s, 1), (i8* %d, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, 1)
define void @test1(i8* %s, i8* %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i32 1, i1 false)
store i8 1, i8* %b, align 1
ret void
}
; CHECK: Alias sets for function 'test2':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, 1)
; CHECK-NOT: 1 Unknown instructions
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref [volatile] Pointers: (i8* %s, 1), (i8* %d, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, 1)
define void @test2(i8* %s, i8* %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i32 1, i1 true)
store i8 1, i8* %b, align 1
ret void
}
; CHECK: Alias sets for function 'test3':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, 1)
; CHECK-NOT: 1 Unknown instructions
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %s, 1), (i8* %d, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, 1)
define void @test3(i8* %s, i8* %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i32 1, i1 false)
store i8 1, i8* %b, align 1
ret void
}
; CHECK: Alias sets for function 'test4':
; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, 1)
; CHECK-NOT: 1 Unknown instructions
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref [volatile] Pointers: (i8* %s, 1), (i8* %d, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, 1)
define void @test4(i8* %s, i8* %d) {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i32 1, i1 true)
store i8 1, i8* %b, align 1
ret void
}
; CHECK: Alias sets for function 'test5':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, 1)
define void @test5() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i32 1, i1 false)
store i8 1, i8* %b, align 1
ret void
}
; CHECK: Alias sets for function 'test6':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, 1)
define void @test6() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memmove.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i32 1, i1 false)
store i8 1, i8* %b, align 1
ret void
}
; CHECK: Alias sets for function 'test7':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %a, 1)
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref Pointers: (i8* %b, 1)
define void @test7() {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i32 1, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1, i32 1, i1 false)
store i8 1, i8* %b, align 1
ret void
}
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1)