From 9b636cb3385376faa7f33a943cac7d40bff1531a Mon Sep 17 00:00:00 2001
From: Owen Anderson <resistor@mac.com>
Date: Sun, 17 Feb 2008 21:29:08 +0000
Subject: [PATCH] Teach getModRefInfo that memcpy, memmove, and memset don't
 "capture" memory addresses. 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
---
 lib/Analysis/BasicAliasAnalysis.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp
index be8fe07f2c9..430e74a98bf 100644
--- a/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/lib/Analysis/BasicAliasAnalysis.cpp
@@ -21,7 +21,7 @@
 #include "llvm/ParameterAttributes.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/Instructions.h"
-#include "llvm/Intrinsics.h"
+#include "llvm/IntrinsicInst.h"
 #include "llvm/Pass.h"
 #include "llvm/Target/TargetData.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
       // callees could modify it.
       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:
       return true;
     }
@@ -247,8 +254,11 @@ BasicAliasAnalysis::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
     // Allocations and byval arguments are "new" objects.
     if (Object &&
         (isa<AllocationInst>(Object) ||
-         (isa<Argument>(Object) && cast<Argument>(Object)->hasByValAttr()))) {
-      // Okay, the pointer is to a stack allocated object.  If we can prove that
+         (isa<Argument>(Object) &&
+                                 (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,
       // because it simply can't get its address.
       if (!AddressMightEscape(Object))