6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-15 04:30:12 +00:00
Code Issues Projects Releases Wiki Activity

Teach getModRefInfo that memcpy, memmove, and memset don't "capture" memory addresses.

Browse Source 
Also, noalias arguments are be considered "like" stack allocated ones for this purpose, because
the only way they can be modref'ed is if they escape somewhere in the current function.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47247 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2008-02-17 21:29:08 +00:00
parent dd12f96c5e
commit 9b636cb338
1 changed files with 13 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -21,7 +21,7 @@
#include "llvm/ParameterAttributes.h" #include "llvm/ParameterAttributes.h"
#include "llvm/GlobalVariable.h" #include "llvm/GlobalVariable.h"
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/Intrinsics.h" #include "llvm/IntrinsicInst.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/Target/TargetData.h" #include "llvm/Target/TargetData.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
@ -228,6 +228,13 @@ static bool AddressMightEscape(const Value *V) {
// If returned, the address will escape to calling functions, but no // If returned, the address will escape to calling functions, but no
// callees could modify it. // callees could modify it.
break; // next use break; // next use
case Instruction::Call:
// If the call is to a few known safe intrinsics, we know that it does
// not escape
if (isa<MemIntrinsic>(I))
return false;
else
return true;
default: default:
return true; return true;
} }
@ -247,8 +254,11 @@ BasicAliasAnalysis::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
// Allocations and byval arguments are "new" objects. // Allocations and byval arguments are "new" objects.
if (Object && if (Object &&
(isa<AllocationInst>(Object) || (isa<AllocationInst>(Object) ||
(isa<Argument>(Object) && cast<Argument>(Object)->hasByValAttr()))) { (isa<Argument>(Object) &&
// Okay, the pointer is to a stack allocated object. If we can prove that (cast<Argument>(Object)->hasByValAttr() ||
cast<Argument>(Object)->hasNoAliasAttr())))) {
// Okay, the pointer is to a stack allocated (or effectively so, for
// for noalias parameters) object. If we can prove that
// the pointer never "escapes", then we know the call cannot clobber it, // the pointer never "escapes", then we know the call cannot clobber it,
// because it simply can't get its address. // because it simply can't get its address.
if (!AddressMightEscape(Object)) if (!AddressMightEscape(Object))