Add, and infer, a nofree function attribute

[homerdin]

Summary

This patch adds a function attribute, nofree, to indicate that a function does not, directly or indirectly, call a memory-deallocation function (e.g., free, C++'s operator delete).

The primary motivation for adding this attribute some from the discussion about how to fix the semantics, or the use of, the dereferenceable attribute on C++ references passed as function parameters. The problem is that, while a reference argument is known to be dereferenceable when the function starts executing, nothing prevents the function from freeing the memory. As a result, it is wrong to assume that the pointer is dereferenceable over the entire body of the function unless we can rule out a situation where the memory might be deallocated during the course of the function's execution. For more information, please see the discussion in https://reviews.llvm.org/D48239.

For more information, see the RFC.

[efriedma]

docs/LangRef.rst

1439 ↗

(On Diff #154913)

The "uncaptured" bit makes this useless for D48239; we have to assume any argument that isn't noalias is captured.

lib/Transforms/IPO/FunctionAttrs.cpp

1228 ↗

(On Diff #154913)

This seems delicate; there are some C library functions which aren't "free", but can still free memory (like mmap). Not sure we recognize any functions like that at the moment, but we could add them. I'd prefer to add explicit logic to inferLibFuncAttributes.

If you are going to call getLibFunc, use the overload that takes a CallSite.

[hfinkel]

docs/LangRef.rst

1439 ↗

(On Diff #154913)

I agree. In the RFC I just sent out a few seconds ago, I proposed a different solution (to also have a nosynch attribute).

lib/Transforms/IPO/FunctionAttrs.cpp

1228 ↗

(On Diff #154913)

This seems delicate; there are some C library functions which aren't "free", but can still free memory (like mmap). Not sure we recognize any functions like that at the moment, but we could add them. I'd prefer to add explicit logic to inferLibFuncAttributes.

This also makes me uneasy. On the other hand, maintaining a separate list of functions which don't free memory, which is nearly all of them, also seems bad. My best suggestion is to add a strongly-worded note to include/llvm/Analysis/TargetLibraryInfo.def about what to do if you add such a function that frees memory. Would that be okay?

[efriedma]

lib/Transforms/IPO/FunctionAttrs.cpp

1228 ↗

(On Diff #154913)

I guess it's okay to default all known functions which aren't free-like/realloc-like to infer nofree, with an appropriate comment.

I'd still prefer to move the code to infer nofree on library calls to inferLibFuncAttributes.

[homerdin]

Going to rebase this.

[homerdin]

Rebased

[jdoerfert]

docs/LangRef.rst

1460 ↗

(On Diff #204348)

The question now is, do we want nofree to be orthogonal to nosync or not? I'd prefer yes but it can confuse people so we should add language here to make that explicit.

lib/Analysis/MemoryBuiltins.cpp

271 ↗

(On Diff #204348)

See my comment at the use.

lib/Bitcode/Reader/BitcodeReader.cpp

1194 ↗

(On Diff #204348)

I don't think you can do this. All existing attributes have to keep their "encoding" and new ones get the next free number which has to match include/llvm/Bitcode/LLVMBitCodes.h.

lib/Transforms/IPO/FunctionAttrs.cpp

1228 ↗

(On Diff #154913)

I also think we should move deduction logic for library functions to inferLibFuncAttributes and annotate intrinsics properly.

1242 ↗

(On Diff #204348)

Why is this needed? The below logic should be sufficient because we want to check for "must not free" and therefore it doesn't matter if a function is "must-free" or "may-free".

1244 ↗

(On Diff #204348)

Check if(!CS) (below) instead of these isa's which are not exhaustive.

1253 ↗

(On Diff #204348)

I'd like to "simply" ask the call site for nofree and doesNotReadMemory, or make doesNotFreeMemory a CallBase method with redirects in CallSite. That allows to annotate the call site directly.

[uenoku]

@homerdin
I want to use nofree enum attribute in D62687. If it's OK with you, can I take over this patch?

[homerdin]

@uenoku Sure. I'm working on moving the logic for library functions to inferLibFuncAttributes, but I can add that in later.

[homerdin]

I moved the logic for library functions to inferLibFuncAttributes, added a note to TargetLibraryInfo.def and updated the tests

[jdoerfert]

Except the TLI related changes (see below) I think this looks good now.

lib/Transforms/IPO/FunctionAttrs.cpp

1521 ↗

(On Diff #205113)

TLI should be unused in this file and all related changes should be undone.

llvm/trunk/docs/LangRef.rst

``noduplicate``
     within its parent function, but may not be duplicated within
     its parent function.
 
     A function containing a ``noduplicate`` call may still
     be an inlining candidate, provided that the call is not
     duplicated by inlining. That implies that the function has
     internal linkage and only has one call site, so the original
     call is dead after inlining.
+``nofree``
+    This function attribute indicates that the function does not, directly or
+    indirectly, call a memory-deallocation function (free, for example). As a
+    result, uncaptured pointers that are known to be dereferenceable prior to a
+    call to a function with the ``nofree`` attribute are still known to be
+    dereferenceable after the call (the capturing condition is necessary in
+    environments where the function might communicate the pointer to another thread
+    which then deallocates the memory).
 ``noimplicitfloat``
     This attributes disables implicit floating-point instructions.
 ``noinline``
     This attribute indicates that the inliner should never inline this
     function in any situation. This attribute may not be used together
     with the ``alwaysinline`` attribute.
 ``nonlazybind``
     This attribute suppresses lazy symbol binding for the function. This

llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h

 
 #ifndef LLVM_ANALYSIS_MEMORYBUILTINS_H
 #define LLVM_ANALYSIS_MEMORYBUILTINS_H
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/TargetFolder.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/ValueHandle.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {

 bool isMallocOrCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
                             bool LookThroughBitCast = false);
 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates memory (either malloc, calloc, or strdup like).
 bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
                    bool LookThroughBitCast = false);
 
+/// Tests if a value is a call or invoke to a library function that
+/// reallocates memory (e.g., realloc).
+bool isReallocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
+                     bool LookThroughBitCast = false);
+
+/// Tests if a function is a call or invoke to a library function that
+/// reallocates memory (e.g., realloc).
+bool isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI);
+
 //===----------------------------------------------------------------------===//
 //  malloc Call Utility Functions.
 //
 
 /// extractMallocCall - Returns the corresponding CallInst if the instruction
 /// is a malloc call.  Since CallInst::CreateMalloc() only creates calls, we
 /// ignore InvokeInst here.
 const CallInst *extractMallocCall(const Value *I, const TargetLibraryInfo *TLI);
inline CallInst *extractCallocCall(Value *I, const TargetLibraryInfo *TLI) {
   return const_cast<CallInst*>(extractCallocCall((const Value*)I, TLI));
 }
 
 
 //===----------------------------------------------------------------------===//
 //  free Call Utility Functions.
 //
 
+/// isLibFreeFunction - Returns true if the function is a builtin free()
+bool isLibFreeFunction(const Function *F, const LibFunc TLIFn);
+
 /// isFreeCall - Returns non-null if the value is a call to the builtin free()
 const CallInst *isFreeCall(const Value *I, const TargetLibraryInfo *TLI);
 
 inline CallInst *isFreeCall(Value *I, const TargetLibraryInfo *TLI) {
   return const_cast<CallInst*>(isFreeCall((const Value*)I, TLI));
 }
 
 //===----------------------------------------------------------------------===//

llvm/trunk/include/llvm/Analysis/TargetLibraryInfo.def

 //===-- TargetLibraryInfo.def - Library information -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // This .def file will either fill in the enum definition or fill in the
 // string representation array definition for TargetLibraryInfo.
 // Which is defined depends on whether TLI_DEFINE_ENUM is defined or
 // TLI_DEFINE_STRING is defined. Only one should be defined at a time.
 
+// NOTE: The nofree attribute is added to Libfuncs which are not
+// listed as free or realloc functions in MemoryBuiltins.cpp
+//
+// When adding a function which frees memory include the LibFunc
+// in lib/Analysis/MemoryBuiltins.cpp "isLibFreeFunction".
+//
+// When adding a LibFunc which reallocates memory include the LibFunc
+// in lib/Analysis/MemoryBuiltins.cpp "AllocationFnData[]".
+
 #if !(defined(TLI_DEFINE_ENUM) || defined(TLI_DEFINE_STRING))
 #error "Must define TLI_DEFINE_ENUM or TLI_DEFINE_STRING for TLI .def."
 #elif defined(TLI_DEFINE_ENUM) && defined(TLI_DEFINE_STRING)
 #error "Can only define one of TLI_DEFINE_ENUM or TLI_DEFINE_STRING at a time."
 #else
 // One of TLI_DEFINE_ENUM/STRING are defined.
 
 #if defined(TLI_DEFINE_ENUM)

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
   ATTR_KIND_STRICT_FP = 54,
   ATTR_KIND_SANITIZE_HWADDRESS = 55,
   ATTR_KIND_NOCF_CHECK = 56,
   ATTR_KIND_OPT_FOR_FUZZING = 57,
   ATTR_KIND_SHADOWCALLSTACK = 58,
   ATTR_KIND_SPECULATIVE_LOAD_HARDENING = 59,
   ATTR_KIND_IMMARG = 60,
   ATTR_KIND_WILLRETURN = 61,
+  ATTR_KIND_NOFREE = 62
 };
 
 enum ComdatSelectionKindCodes {
   COMDAT_SELECTION_KIND_ANY = 1,
   COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
   COMDAT_SELECTION_KIND_LARGEST = 3,
   COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
   COMDAT_SELECTION_KIND_SAME_SIZE = 5,

llvm/trunk/include/llvm/IR/Attributes.td

 def NoBuiltin : EnumAttr<"nobuiltin">;
 
 /// Function creates no aliases of pointer.
 def NoCapture : EnumAttr<"nocapture">;
 
 /// Call cannot be duplicated.
 def NoDuplicate : EnumAttr<"noduplicate">;
 
+/// Function does not deallocate memory.
+def NoFree : EnumAttr<"nofree">;
+
 /// Disable implicit floating point insts.
 def NoImplicitFloat : EnumAttr<"noimplicitfloat">;
 
 /// inline=never.
 def NoInline : EnumAttr<"noinline">;
 
 /// Function is called early and/or often, so lazy binding isn't worthwhile.
 def NonLazyBind : EnumAttr<"nonlazybind">;

llvm/trunk/include/llvm/IR/Function.h

public:
   /// Determine if the call has sideeffects.
   bool isSpeculatable() const {
     return hasFnAttribute(Attribute::Speculatable);
   }
   void setSpeculatable() {
     addFnAttr(Attribute::Speculatable);
   }
 
+  /// Determine if the call might deallocate memory.
+  bool doesNotFreeMemory() const {
+    return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);
+  }
+  void setDoesNotFreeMemory() {
+    addFnAttr(Attribute::NoFree);
+  }
+
   /// Determine if the function is known not to recurse, directly or
   /// indirectly.
   bool doesNotRecurse() const {
     return hasFnAttribute(Attribute::NoRecurse);
   }
   void setDoesNotRecurse() {
     addFnAttr(Attribute::NoRecurse);
   }

llvm/trunk/lib/Analysis/MemoryBuiltins.cpp

 
 /// Tests if a value is a call or invoke to a library function that
 /// allocates memory (either malloc, calloc, or strdup like).
 bool llvm::isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
                          bool LookThroughBitCast) {
   return getAllocationData(V, AllocLike, TLI, LookThroughBitCast).hasValue();
 }
 
+/// Tests if a value is a call or invoke to a library function that
+/// reallocates memory (e.g., realloc).
+bool llvm::isReallocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
+                     bool LookThroughBitCast) {
+  return getAllocationData(V, ReallocLike, TLI, LookThroughBitCast).hasValue();
+}
+
+/// Tests if a functions is a call or invoke to a library function that
+/// reallocates memory (e.g., realloc).
+bool llvm::isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI) {
+  return getAllocationDataForFunction(F, ReallocLike, TLI).hasValue();
+}
+
 /// extractMallocCall - Returns the corresponding CallInst if the instruction
 /// is a malloc call.  Since CallInst::CreateMalloc() only creates calls, we
 /// ignore InvokeInst here.
 const CallInst *llvm::extractMallocCall(const Value *I,
                                         const TargetLibraryInfo *TLI) {
   return isMallocLikeFn(I, TLI) ? dyn_cast<CallInst>(I) : nullptr;
 }
 

 
 /// extractCallocCall - Returns the corresponding CallInst if the instruction
 /// is a calloc call.
 const CallInst *llvm::extractCallocCall(const Value *I,
                                         const TargetLibraryInfo *TLI) {
   return isCallocLikeFn(I, TLI) ? cast<CallInst>(I) : nullptr;
 }
 
-/// isFreeCall - Returns non-null if the value is a call to the builtin free()
-const CallInst *llvm::isFreeCall(const Value *I, const TargetLibraryInfo *TLI) {
-  bool IsNoBuiltinCall;
-  const Function *Callee =
-      getCalledFunction(I, /*LookThroughBitCast=*/false, IsNoBuiltinCall);
-  if (Callee == nullptr || IsNoBuiltinCall)
-    return nullptr;
-
-  StringRef FnName = Callee->getName();
-  LibFunc TLIFn;
-  if (!TLI || !TLI->getLibFunc(FnName, TLIFn) || !TLI->has(TLIFn))
-    return nullptr;
-
+/// isLibFreeFunction - Returns true if the function is a builtin free()
+bool llvm::isLibFreeFunction(const Function *F, const LibFunc TLIFn) {
   unsigned ExpectedNumParams;
   if (TLIFn == LibFunc_free ||
       TLIFn == LibFunc_ZdlPv || // operator delete(void*)
       TLIFn == LibFunc_ZdaPv || // operator delete[](void*)
       TLIFn == LibFunc_msvc_delete_ptr32 || // operator delete(void*)
       TLIFn == LibFunc_msvc_delete_ptr64 || // operator delete(void*)
       TLIFn == LibFunc_msvc_delete_array_ptr32 || // operator delete[](void*)
       TLIFn == LibFunc_msvc_delete_array_ptr64)   // operator delete[](void*)
else if (TLIFn == LibFunc_ZdlPvj ||              // delete(void*, uint)
            TLIFn == LibFunc_msvc_delete_array_ptr64_longlong || // delete[](void*, ulonglong)
            TLIFn == LibFunc_msvc_delete_array_ptr32_nothrow || // delete[](void*, nothrow)
            TLIFn == LibFunc_msvc_delete_array_ptr64_nothrow)   // delete[](void*, nothrow)
     ExpectedNumParams = 2;
   else if (TLIFn == LibFunc_ZdaPvSt11align_val_tRKSt9nothrow_t || // delete(void*, align_val_t, nothrow)
            TLIFn == LibFunc_ZdlPvSt11align_val_tRKSt9nothrow_t) // delete[](void*, align_val_t, nothrow)
     ExpectedNumParams = 3;
   else
-    return nullptr;
+    return false;
 
   // Check free prototype.
   // FIXME: workaround for PR5130, this will be obsolete when a nobuiltin
   // attribute will exist.
-  FunctionType *FTy = Callee->getFunctionType();
+  FunctionType *FTy = F->getFunctionType();
   if (!FTy->getReturnType()->isVoidTy())
-    return nullptr;
+    return false;
   if (FTy->getNumParams() != ExpectedNumParams)
+    return false;
+  if (FTy->getParamType(0) != Type::getInt8PtrTy(F->getContext()))
+    return false;
+
+  return true;
+}
+
+/// isFreeCall - Returns non-null if the value is a call to the builtin free()
+const CallInst *llvm::isFreeCall(const Value *I, const TargetLibraryInfo *TLI) {
+  bool IsNoBuiltinCall;
+  const Function *Callee =
+      getCalledFunction(I, /*LookThroughBitCast=*/false, IsNoBuiltinCall);
+  if (Callee == nullptr || IsNoBuiltinCall)
     return nullptr;
-  if (FTy->getParamType(0) != Type::getInt8PtrTy(Callee->getContext()))
+
+  StringRef FnName = Callee->getName();
+  LibFunc TLIFn;
+  if (!TLI || !TLI->getLibFunc(FnName, TLIFn) || !TLI->has(TLIFn))
     return nullptr;
 
-  return dyn_cast<CallInst>(I);
+  return isLibFreeFunction(Callee, TLIFn) ? dyn_cast<CallInst>(I) : nullptr;
 }
 
+
 //===----------------------------------------------------------------------===//
 //  Utility functions to compute size of objects.
 //
 static APInt getSizeWithOverflow(const SizeOffsetType &Data) {
   if (Data.second.isNegative() || Data.first.ult(Data.second))
     return APInt(Data.first.getBitWidth(), 0);
   return Data.first - Data.second;
 }

llvm/trunk/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(jumptable);
   KEYWORD(minsize);
   KEYWORD(naked);
   KEYWORD(nest);
   KEYWORD(noalias);
   KEYWORD(nobuiltin);
   KEYWORD(nocapture);
   KEYWORD(noduplicate);
+  KEYWORD(nofree);
   KEYWORD(noimplicitfloat);
   KEYWORD(noinline);
   KEYWORD(norecurse);
   KEYWORD(nonlazybind);
   KEYWORD(nonnull);
   KEYWORD(noredzone);
   KEYWORD(noreturn);
   KEYWORD(nocf_check);

llvm/trunk/lib/AsmParser/LLParser.cpp

while (true) {
     case lltok::kw_inaccessiblemem_or_argmemonly:
       B.addAttribute(Attribute::InaccessibleMemOrArgMemOnly); break;
     case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
     case lltok::kw_jumptable: B.addAttribute(Attribute::JumpTable); break;
     case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
     case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
     case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
     case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
+    case lltok::kw_nofree: B.addAttribute(Attribute::NoFree); break;
     case lltok::kw_noimplicitfloat:
       B.addAttribute(Attribute::NoImplicitFloat); break;
     case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
     case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
     case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
     case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
     case lltok::kw_nocf_check: B.addAttribute(Attribute::NoCfCheck); break;
     case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break;

llvm/trunk/lib/AsmParser/LLToken.h

enum Kind {
   kw_jumptable,
   kw_minsize,
   kw_naked,
   kw_nest,
   kw_noalias,
   kw_nobuiltin,
   kw_nocapture,
   kw_noduplicate,
+  kw_nofree,
   kw_noimplicitfloat,
   kw_noinline,
   kw_norecurse,
   kw_nonlazybind,
   kw_nonnull,
   kw_noredzone,
   kw_noreturn,
   kw_nocf_check,

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

static uint64_t getRawAttributeMask(Attribute::AttrKind Val) {
   case Attribute::OptForFuzzing:   return 1ULL << 58;
   case Attribute::ShadowCallStack: return 1ULL << 59;
   case Attribute::SpeculativeLoadHardening:
     return 1ULL << 60;
   case Attribute::ImmArg:
     return 1ULL << 61;
   case Attribute::WillReturn:
     return 1ULL << 62;
+  case Attribute::NoFree:
+    return 1ULL << 63;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
     break;
   case Attribute::DereferenceableOrNull:
     llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
                      "format");
     break;
   case Attribute::ArgMemOnly:
static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_NO_ALIAS:
     return Attribute::NoAlias;
   case bitc::ATTR_KIND_NO_BUILTIN:
     return Attribute::NoBuiltin;
   case bitc::ATTR_KIND_NO_CAPTURE:
     return Attribute::NoCapture;
   case bitc::ATTR_KIND_NO_DUPLICATE:
     return Attribute::NoDuplicate;
+  case bitc::ATTR_KIND_NOFREE:
+    return Attribute::NoFree;
   case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT:
     return Attribute::NoImplicitFloat;
   case bitc::ATTR_KIND_NO_INLINE:
     return Attribute::NoInline;
   case bitc::ATTR_KIND_NO_RECURSE:
     return Attribute::NoRecurse;
   case bitc::ATTR_KIND_NON_LAZY_BIND:
     return Attribute::NonLazyBind;

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::NoAlias:
     return bitc::ATTR_KIND_NO_ALIAS;
   case Attribute::NoBuiltin:
     return bitc::ATTR_KIND_NO_BUILTIN;
   case Attribute::NoCapture:
     return bitc::ATTR_KIND_NO_CAPTURE;
   case Attribute::NoDuplicate:
     return bitc::ATTR_KIND_NO_DUPLICATE;
+  case Attribute::NoFree:
+    return bitc::ATTR_KIND_NOFREE;
   case Attribute::NoImplicitFloat:
     return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;
   case Attribute::NoInline:
     return bitc::ATTR_KIND_NO_INLINE;
   case Attribute::NoRecurse:
     return bitc::ATTR_KIND_NO_RECURSE;
   case Attribute::NonLazyBind:
     return bitc::ATTR_KIND_NON_LAZY_BIND;

llvm/trunk/lib/IR/Attributes.cpp

std::string Attribute::getAsString(bool InAttrGrp) const {
   if (hasAttribute(Attribute::NoAlias))
     return "noalias";
   if (hasAttribute(Attribute::NoBuiltin))
     return "nobuiltin";
   if (hasAttribute(Attribute::NoCapture))
     return "nocapture";
   if (hasAttribute(Attribute::NoDuplicate))
     return "noduplicate";
+  if (hasAttribute(Attribute::NoFree))
+    return "nofree";
   if (hasAttribute(Attribute::NoImplicitFloat))
     return "noimplicitfloat";
   if (hasAttribute(Attribute::NoInline))
     return "noinline";
   if (hasAttribute(Attribute::NonLazyBind))
     return "nonlazybind";
   if (hasAttribute(Attribute::NonNull))
     return "nonnull";

llvm/trunk/lib/IR/Verifier.cpp

 /// Return true if this attribute kind only applies to functions.
 static bool isFuncOnlyAttr(Attribute::AttrKind Kind) {
   switch (Kind) {
   case Attribute::NoReturn:
   case Attribute::WillReturn:
   case Attribute::NoCfCheck:
   case Attribute::NoUnwind:
   case Attribute::NoInline:
+  case Attribute::NoFree:
   case Attribute::AlwaysInline:
   case Attribute::OptimizeForSize:
   case Attribute::StackProtect:
   case Attribute::StackProtectReq:
   case Attribute::StackProtectStrong:
   case Attribute::SafeStack:
   case Attribute::ShadowCallStack:
   case Attribute::NoRedZone:

llvm/trunk/lib/Transforms/IPO/FunctionAttrs.cpp

 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"

 STATISTIC(NumNoCapture, "Number of arguments marked nocapture");
 STATISTIC(NumReturned, "Number of arguments marked returned");
 STATISTIC(NumReadNoneArg, "Number of arguments marked readnone");
 STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly");
 STATISTIC(NumNoAlias, "Number of function returns marked noalias");
 STATISTIC(NumNonNullReturn, "Number of function returns marked nonnull");
 STATISTIC(NumNoRecurse, "Number of functions marked as norecurse");
 STATISTIC(NumNoUnwind, "Number of functions marked as nounwind");
+STATISTIC(NumNoFree, "Number of functions marked as nofree");
 
 // FIXME: This is disabled by default to avoid exposing security vulnerabilities
 // in C/C++ code compiled by clang:
 // http://lists.llvm.org/pipermail/cfe-dev/2017-January/052066.html
 static cl::opt<bool> EnableNonnullArgPropagation(
     "enable-nonnull-arg-prop", cl::Hidden,
     cl::desc("Try to propagate nonnull argument attributes from callsites to "
              "caller functions."));
 
 static cl::opt<bool> DisableNoUnwindInference(
     "disable-nounwind-inference", cl::Hidden,
     cl::desc("Stop inferring nounwind attribute during function-attrs pass"));
 
+static cl::opt<bool> DisableNoFreeInference(
+    "disable-nofree-inference", cl::Hidden,
+    cl::desc("Stop inferring nofree attribute during function-attrs pass"));
+
 namespace {
 
 using SCCNodeSet = SmallSetVector<Function *, 8>;
 
 } // end anonymous namespace
 
 /// Returns the memory access attribute for function F using AAR for AA results,
 /// where SCCNodes is the current SCC.
if (Function *Callee = CI->getCalledFunction()) {
       // just have to scan that other function.
       if (SCCNodes.count(Callee) > 0)
         return false;
     }
   }
   return true;
 }
 
+/// Helper for NoFree inference predicate InstrBreaksAttribute.
+static bool InstrBreaksNoFree(Instruction &I, const SCCNodeSet &SCCNodes) {
+  CallSite CS(&I);
+  if (!CS)
+    return false;
+
+  Function *Callee = CS.getCalledFunction();
+  if (!Callee)
+    return true;
+
+  if (Callee->doesNotFreeMemory())
+    return false;
+
+  if (SCCNodes.count(Callee) > 0)
+    return false;
+
+  return true;
+}
+
 /// Infer attributes from all functions in the SCC by scanning every
 /// instruction for compliance to the attribute assumptions. Currently it
 /// does:
 ///   - removal of Convergent attribute
 ///   - addition of NoUnwind attribute
 ///
 /// Returns true if any changes to function attributes were made.
 static bool inferAttrsFromFunctionBodies(const SCCNodeSet &SCCNodes) {
AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
         [](Function &F) {
           LLVM_DEBUG(dbgs()
                      << "Adding nounwind attr to fn " << F.getName() << "\n");
           F.setDoesNotThrow();
           ++NumNoUnwind;
         },
         /* RequiresExactDefinition= */ true});
 
+  if (!DisableNoFreeInference)
+    // Request to infer nofree attribute for all the functions in the SCC if
+    // every callsite within the SCC does not directly or indirectly free
+    // memory (except for calls to functions within the SCC). Note that nofree
+    // attribute suffers from derefinement - results may change depending on
+    // how functions are optimized. Thus it can be inferred only from exact
+    // definitions.
+    AI.registerAttrInference(AttributeInferer::InferenceDescriptor{
+        Attribute::NoFree,
+        // Skip functions known not to free memory.
+        [](const Function &F) { return F.doesNotFreeMemory(); },
+        // Instructions that break non-deallocating assumption.
+        [SCCNodes](Instruction &I) {
+          return InstrBreaksNoFree(I, SCCNodes);
+        },
+        [](Function &F) {
+          LLVM_DEBUG(dbgs()
+                     << "Adding nofree attr to fn " << F.getName() << "\n");
+          F.setDoesNotFreeMemory();
+          ++NumNoFree;
+        },
+        /* RequiresExactDefinition= */ true});
+
   // Perform all the requested attribute inference actions.
   return AI.run(SCCNodes);
 }
 
 static bool setDoesNotRecurse(Function &F) {
   if (F.doesNotRecurse())
     return false;
   F.setDoesNotRecurse();
static bool addNoRecurseAttrs(const SCCNodeSet &SCCNodes) {
 
   // Every call was to a non-recursive function other than this function, and
   // we have no indirect recursion as the SCC size is one. This function cannot
   // recurse.
   return setDoesNotRecurse(*F);
 }
 
 template <typename AARGetterT>
-static bool deriveAttrsInPostOrder(SCCNodeSet &SCCNodes, AARGetterT &&AARGetter,
+static bool deriveAttrsInPostOrder(SCCNodeSet &SCCNodes,
+                                   AARGetterT &&AARGetter,
                                    bool HasUnknownCall) {
   bool Changed = false;
 
   // Bail if the SCC only contains optnone functions.
   if (SCCNodes.empty())
     return Changed;
 
   Changed |= addArgumentReturnedAttrs(SCCNodes);

 
 PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C,
                                                   CGSCCAnalysisManager &AM,
                                                   LazyCallGraph &CG,
                                                   CGSCCUpdateResult &) {
   FunctionAnalysisManager &FAM =
       AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
 
+  const ModuleAnalysisManager &MAM =
+      AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C, CG).getManager();
+  assert(C.size() > 0 && "Cannot handle an empty SCC!");
+  Module &M = *C.begin()->getFunction().getParent();
+
   // We pass a lambda into functions to wire them up to the analysis manager
   // for getting function analyses.
   auto AARGetter = [&](Function &F) -> AAResults & {
     return FAM.getResult<AAManager>(F);
   };
 
   // Fill SCCNodes with the elements of the SCC. Also track whether there are
   // any external or opt-none nodes that will prevent us from optimizing any

llvm/trunk/lib/Transforms/Utils/BuildLibCalls.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
+#include "llvm/Analysis/MemoryBuiltins.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "build-libcalls"
 
 //- Infer Attributes ---------------------------------------------------------//
 
 STATISTIC(NumReadNone, "Number of functions inferred as readnone");

 
 static bool setNonLazyBind(Function &F) {
   if (F.hasFnAttribute(Attribute::NonLazyBind))
     return false;
   F.addFnAttr(Attribute::NonLazyBind);
   return true;
 }
 
+static bool setDoesNotFreeMemory(Function &F) {
+  if (F.hasFnAttribute(Attribute::NoFree))
+    return false;
+  F.addFnAttr(Attribute::NoFree);
+  return true;
+}
+
 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
                                   const TargetLibraryInfo &TLI) {
   Function *F = M->getFunction(Name);
   if (!F)
     return false;
   return inferLibFuncAttributes(*F, TLI);
 }
 
 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
   LibFunc TheLibFunc;
   if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
     return false;
 
   bool Changed = false;
 
+  if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F,  &TLI))
+    Changed |= setDoesNotFreeMemory(F);
+
   if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
     Changed |= setNonLazyBind(F);
 
   switch (TheLibFunc) {
   case LibFunc_strlen:
   case LibFunc_wcslen:
     Changed |= setOnlyReadsMemory(F);
     Changed |= setDoesNotThrow(F);

llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp

if (Attr.isStringAttribute()) {
         continue;
       // Those attributes should be safe to propagate to the extracted function.
       case Attribute::AlwaysInline:
       case Attribute::Cold:
       case Attribute::NoRecurse:
       case Attribute::InlineHint:
       case Attribute::MinSize:
       case Attribute::NoDuplicate:
+      case Attribute::NoFree:
       case Attribute::NoImplicitFloat:
       case Attribute::NoInline:
       case Attribute::NonLazyBind:
       case Attribute::NoRedZone:
       case Attribute::NoUnwind:
       case Attribute::OptForFuzzing:
       case Attribute::OptimizeNone:
       case Attribute::OptimizeForSize:

llvm/trunk/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll

define i32 @test3_no(i8* %p) nounwind {
   %t = va_arg i8* %p, i32, !tbaa !2
   ret i32 %t
 }
 
 declare void @callee(i32* %p) nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1) nounwind
 
 ; CHECK: attributes #0 = { norecurse nounwind readnone }
-; CHECK: attributes #1 = { norecurse nounwind writeonly }
+; CHECK: attributes #1 = { nofree norecurse nounwind writeonly }
 ; CHECK: attributes #2 = { nounwind readonly }
 ; CHECK: attributes #3 = { nounwind }
 ; CHECK: attributes #4 = { nounwind readnone }
-; CHECK: attributes #5 = { norecurse nounwind }
+; CHECK: attributes #5 = { nofree norecurse nounwind }
 ; CHECK: attributes #6 = { argmemonly nounwind }
 
 ; Root note.
 !0 = !{ }
 
 ; Invariant memory.
 !1 = !{!3, !3, i64 0, i1 1 }
 ; Not invariant memory.
 !2 = !{!3, !3, i64 0, i1 0 }
 !3 = !{ !"foo", !0 }

llvm/trunk/test/Bitcode/attributes.ll

 }
 
 declare void @nobuiltin()
 
 define void @f34()
 ; CHECK: define void @f34()
 {
         call void @nobuiltin() nobuiltin
-; CHECK: call void @nobuiltin() #37
+; CHECK: call void @nobuiltin() #38
         ret void;
 }
 
 define void @f35() optnone noinline
 ; CHECK: define void @f35() #23
 {
         ret void;
 }

 }
 
 ; CHECK: define void @f60() #36
 define void @f60() willreturn
 {
   ret void
 }
 
+; CHECK: define void @f61() #37
+define void @f61() nofree {
+  ret void
+}
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { readnone }
 ; CHECK: attributes #3 = { readonly }
 ; CHECK: attributes #4 = { noinline }
 ; CHECK: attributes #5 = { alwaysinline }
 ; CHECK: attributes #6 = { optsize }
 ; CHECK: attributes #7 = { ssp }

 ; CHECK: attributes #29 = { inaccessiblemem_or_argmemonly }
 ; CHECK: attributes #30 = { allocsize(0) }
 ; CHECK: attributes #31 = { allocsize(0,1) }
 ; CHECK: attributes #32 = { writeonly }
 ; CHECK: attributes #33 = { speculatable }
 ; CHECK: attributes #34 = { sanitize_hwaddress }
 ; CHECK: attributes #35 = { shadowcallstack }
 ; CHECK: attributes #36 = { willreturn }
-; CHECK: attributes #37 = { nobuiltin }
+; CHECK: attributes #37 = { nofree }
+; CHECK: attributes #38 = { nobuiltin }

llvm/trunk/test/CodeGen/AMDGPU/inline-attr.ll

 ; RUN: opt -mtriple=amdgcn--amdhsa -S -O3 -enable-unsafe-fp-math %s  | FileCheck -check-prefix=GCN -check-prefix=UNSAFE %s
 ; RUN: opt -mtriple=amdgcn--amdhsa -S -O3 -enable-no-nans-fp-math %s | FileCheck -check-prefix=GCN -check-prefix=NONANS %s
 ; RUN: opt -mtriple=amdgcn--amdhsa -S -O3 -enable-no-infs-fp-math %s | FileCheck -check-prefix=GCN -check-prefix=NOINFS %s
 
 ; GCN: define float @foo(float %x) local_unnamed_addr #0 {
 ; GCN: define amdgpu_kernel void @caller(float addrspace(1)* nocapture %p) local_unnamed_addr #1 {
 ; GCN: %mul.i = fmul float %load, 1.500000e+01
 
 ; UNSAFE: attributes #0 = { norecurse nounwind readnone "less-precise-fpmad"="true" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "unsafe-fp-math"="true" }
-; UNSAFE: attributes #1 = { norecurse nounwind "less-precise-fpmad"="true" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "unsafe-fp-math"="true" }
+; UNSAFE: attributes #1 = { nofree norecurse nounwind "less-precise-fpmad"="true" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "unsafe-fp-math"="true" }
 
 ; NOINFS: attributes #0 = { norecurse nounwind readnone "no-infs-fp-math"="true" }
-; NOINFS: attributes #1 = { norecurse nounwind "less-precise-fpmad"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="false" "unsafe-fp-math"="false" }
+; NOINFS: attributes #1 = { nofree norecurse nounwind "less-precise-fpmad"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="false" "unsafe-fp-math"="false" }
 
 ; NONANS: attributes #0 = { norecurse nounwind readnone "no-nans-fp-math"="true" }
-; NONANS: attributes #1 = { norecurse nounwind "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="true" "unsafe-fp-math"="false" }
+; NONANS: attributes #1 = { nofree norecurse nounwind "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="true" "unsafe-fp-math"="false" }
 
 define float @foo(float %x) #0 {
 entry:
   %mul = fmul float %x, 1.500000e+01
   ret float %mul
 }
 
 define amdgpu_kernel void @caller(float addrspace(1)* %p) #1 {

llvm/trunk/test/CodeGen/X86/no-plt-libcalls.ll

 ; Check if "RtLibUseGOT" works correctly when lib calls are simplified.
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 @percent_s = constant [4 x i8] c"%s\0A\00"
 @hello_world = constant [13 x i8] c"hello world\0A\00"
 declare i32 @printf(i8*, ...)
 define void @printf_call() {
   %fmt = getelementptr [4 x i8], [4 x i8]* @percent_s, i32 0, i32 0
   %str = getelementptr [13 x i8], [13 x i8]* @hello_world, i32 0, i32 0
   call i32 (i8*, ...) @printf(i8* %fmt, i8* %str)
 ; CHECK:  call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i64 0, i64 0))
   ret void
 }
 
-; CHECK: Function Attrs: nounwind nonlazybind
+; CHECK: Function Attrs: nofree nounwind nonlazybind
 ; CHECK-NEXT: declare i32 @puts(i8* nocapture readonly)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 7, !"RtLibUseGOT", i32 1}

llvm/trunk/test/Feature/OperandBundles/function-attrs.ll

 ; RUN: opt -S -functionattrs < %s | FileCheck %s
 
 declare void @f_readonly() readonly
 declare void @f_readnone() readnone
 
 define void @test_0(i32* %x) {
 ; FunctionAttrs must not infer readonly / readnone for %x
 
-; CHECK-LABEL: define void @test_0(i32* %x) {
+; CHECK-LABEL: define void @test_0(i32* %x) #2 {
  entry:
  ; CHECK: call void @f_readonly() [ "foo"(i32* %x) ]
   call void @f_readonly() [ "foo"(i32* %x) ]
   ret void
 }
 
 define void @test_1(i32* %x) {
 ; FunctionAttrs must not infer readonly / readnone for %x
 
-; CHECK-LABEL: define void @test_1(i32* %x) {
+; CHECK-LABEL: define void @test_1(i32* %x) #2 {
  entry:
  ; CHECK: call void @f_readnone() [ "foo"(i32* %x) ]
   call void @f_readnone() [ "foo"(i32* %x) ]
   ret void
 }
 
 define void @test_2(i32* %x) {
 ; The "deopt" operand bundle does not capture or write to %x.
 
 ; CHECK-LABEL: define void @test_2(i32* nocapture readonly %x)
  entry:
   call void @f_readonly() [ "deopt"(i32* %x) ]
   ret void
 }
+
+; CHECK: attributes #2 = { nofree }
+

llvm/trunk/test/Transforms/FunctionAttrs/atomic.ll

 define i32 @test2(i32* %x) uwtable ssp {
 ; CHECK: define i32 @test2(i32* nocapture readonly %x) #1 {
 entry:
   %r = load atomic i32, i32* %x seq_cst, align 4
   ret i32 %r
 }
 
 ; CHECK: attributes #0 = { norecurse nounwind readnone ssp uwtable }
-; CHECK: attributes #1 = { norecurse nounwind ssp uwtable }
+; CHECK: attributes #1 = { nofree norecurse nounwind ssp uwtable }

llvm/trunk/test/Transforms/FunctionAttrs/nofree.ll

+; RUN: opt < %s -functionattrs -S | FileCheck %s
+; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; CHECK: define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 {
+define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 {
+entry:
+  tail call void @_Z3extv()
+  ret void
+}
+
+declare void @_Z3extv() local_unnamed_addr
+
+; CHECK: define void @_Z4foo2Pi(i32* nocapture %a) local_unnamed_addr #1 {
+define void @_Z4foo2Pi(i32* nocapture %a) local_unnamed_addr #1 {
+entry:
+  %0 = bitcast i32* %a to i8*
+  tail call void @free(i8* %0) #2
+  ret void
+}
+
+declare void @free(i8* nocapture) local_unnamed_addr #2
+
+; CHECK: define i32 @_Z4foo3Pi(i32* nocapture readonly %a) local_unnamed_addr #3 {
+define i32 @_Z4foo3Pi(i32* nocapture readonly %a) local_unnamed_addr #3 {
+entry:
+  %0 = load i32, i32* %a, align 4
+  ret i32 %0
+}
+
+; CHECK: define double @_Z4foo4Pd(double* nocapture readonly %a) local_unnamed_addr #1 {
+define double @_Z4foo4Pd(double* nocapture readonly %a) local_unnamed_addr #1 {
+entry:
+  %0 = load double, double* %a, align 8
+  %call = tail call double @cos(double %0) #2
+  ret double %call
+}
+
+declare double @cos(double) local_unnamed_addr #2
+
+; CHECK: define noalias i32* @_Z4foo5Pm(i64* nocapture readonly %a) local_unnamed_addr #1 {
+define noalias i32* @_Z4foo5Pm(i64* nocapture readonly %a) local_unnamed_addr #1 {
+entry:
+  %0 = load i64, i64* %a, align 8
+  %call = tail call noalias i8* @malloc(i64 %0) #2
+  %1 = bitcast i8* %call to i32*
+  ret i32* %1
+}
+
+declare noalias i8* @malloc(i64) local_unnamed_addr #2
+
+; CHECK: define noalias i64* @_Z4foo6Pm(i64* nocapture %a) local_unnamed_addr #1 {
+define noalias i64* @_Z4foo6Pm(i64* nocapture %a) local_unnamed_addr #1 {
+entry:
+  %0 = bitcast i64* %a to i8*
+  %1 = load i64, i64* %a, align 8
+  %call = tail call i8* @realloc(i8* %0, i64 %1) #2
+  %2 = bitcast i8* %call to i64*
+  ret i64* %2
+}
+
+declare noalias i8* @realloc(i8* nocapture, i64) local_unnamed_addr #2
+
+; CHECK: define void @_Z4foo7Pi(i32* %a) local_unnamed_addr #1 {
+define void @_Z4foo7Pi(i32* %a) local_unnamed_addr #1 {
+entry:
+  %isnull = icmp eq i32* %a, null
+  br i1 %isnull, label %delete.end, label %delete.notnull
+
+delete.notnull:                                   ; preds = %entry
+  %0 = bitcast i32* %a to i8*
+  tail call void @_ZdlPv(i8* %0) #5
+  br label %delete.end
+
+delete.end:                                       ; preds = %delete.notnull, %entry
+  ret void
+}
+
+declare void @_ZdlPv(i8*) local_unnamed_addr #4
+
+; CHECK: define void @_Z4foo8Pi(i32* %a) local_unnamed_addr #1 {
+define void @_Z4foo8Pi(i32* %a) local_unnamed_addr #1 {
+entry:
+  %isnull = icmp eq i32* %a, null
+  br i1 %isnull, label %delete.end, label %delete.notnull
+
+delete.notnull:                                   ; preds = %entry
+  %0 = bitcast i32* %a to i8*
+  tail call void @_ZdaPv(i8* %0) #5
+  br label %delete.end
+
+delete.end:                                       ; preds = %delete.notnull, %entry
+  ret void
+}
+
+declare void @_ZdaPv(i8*) local_unnamed_addr #4
+
+attributes #0 = { uwtable }
+attributes #1 = { nounwind uwtable }
+attributes #2 = { nounwind }
+attributes #3 = { norecurse nounwind readonly uwtable }
+attributes #4 = { nobuiltin nounwind }
+attributes #5 = { builtin nounwind }
+
+; CHECK: attributes #0 = { uwtable }
+; CHECK: attributes #1 = { nounwind uwtable }
+; CHECK: attributes #2 = { nounwind }
+; CHECK: attributes #3 = { norecurse nounwind readonly uwtable }
+; CHECK: attributes #4 = { nobuiltin nounwind }
+; CHECK: attributes #5 = { builtin nounwind }
+

llvm/trunk/test/Transforms/FunctionAttrs/operand-bundles-scc.ll

 ; RUN: opt -S -functionattrs < %s | FileCheck %s
 ; RUN: opt -S -passes=function-attrs < %s | FileCheck %s
 
 define void @f() {
 ; CHECK-LABEL:  define void @f() #0 {
  call void @g() [ "unknown"() ]
  ret void
 }
 
 define void @g() {
 ; CHECK-LABEL:  define void @g() #0 {
  call void @f()
  ret void
 }
 
 
-; CHECK: attributes #0 = { nounwind }
+; CHECK: attributes #0 = { nofree nounwind }

llvm/trunk/test/Transforms/FunctionAttrs/read_write_returned_arguments_scc.ll

 ;  16 - Number of arguments marked nocapture
 ;   4 - Number of arguments marked readnone
 ;   6 - Number of arguments marked writeonly
 ;   6 - Number of arguments marked readonly
 ;   6 - Number of arguments marked returned
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
-; CHECK: Function Attrs: nounwind
+; CHECK: Function Attrs: nofree nounwind
 ; CHECK-NEXT: define i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
 define i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %call = call i32* @internal_ret0_nw(i32* %n0, i32* %w0)
   %call1 = call i32* @internal_ret1_rrw(i32* %r0, i32* %r0, i32* %w0)
   %call2 = call i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   %call3 = call i32* @internal_ret1_rw(i32* %r0, i32* %w0)
   ret i32* %call3
 }
 
-; CHECK: Function Attrs: nounwind
+; CHECK: Function Attrs: nofree nounwind
 ; CHECK-NEXT: define internal i32* @internal_ret0_nw(i32* %n0, i32* %w0)
 define internal i32* @internal_ret0_nw(i32* %n0, i32* %w0) {
 entry:
   %r0 = alloca i32, align 4
   %r1 = alloca i32, align 4
   %tobool = icmp ne i32* %n0, null
   br i1 %tobool, label %if.end, label %if.then
 
if.end:                                           ; preds = %entry
   %call5 = call i32* @internal_ret0_nw(i32* %n0, i32* %w0)
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call5, %if.end ], [ %n0, %if.then ]
   ret i32* %retval.0
 }
 
-; CHECK: Function Attrs: nounwind
+; CHECK: Function Attrs: nofree nounwind
 ; CHECK-NEXT: define internal i32* @internal_ret1_rrw(i32* %r0, i32* %r1, i32* %w0)
 define internal i32* @internal_ret1_rrw(i32* %r0, i32* %r1, i32* %w0) {
 entry:
   %0 = load i32, i32* %r0, align 4
   %tobool = icmp ne i32 %0, 0
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
if.end:                                           ; preds = %entry
   %call8 = call i32* @internal_ret0_nw(i32* %r1, i32* %w0)
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call8, %if.end ], [ %r1, %if.then ]
   ret i32* %retval.0
 }
 
-; CHECK: Function Attrs: norecurse nounwind
+; CHECK: Function Attrs: nofree norecurse nounwind
 ; CHECK-NEXT: define i32* @external_sink_ret2_nrw(i32* readnone %n0, i32* nocapture readonly %r0, i32* returned %w0)
 define i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %tobool = icmp ne i32* %n0, null
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
   br label %return
 
 if.end:                                           ; preds = %entry
   %0 = load i32, i32* %r0, align 4
   store i32 %0, i32* %w0, align 4
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   ret i32* %w0
 }
 
-; CHECK: Function Attrs: nounwind
+; CHECK: Function Attrs: nofree nounwind
 ; CHECK-NEXT: define internal i32* @internal_ret1_rw(i32* %r0, i32* %w0)
 define internal i32* @internal_ret1_rw(i32* %r0, i32* %w0) {
 entry:
   %0 = load i32, i32* %r0, align 4
   %tobool = icmp ne i32 %0, 0
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
if.end:                                           ; preds = %entry
   %call4 = call i32* @external_ret2_nrw(i32* %r0, i32* %r0, i32* %w0)
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call4, %if.end ], [ %w0, %if.then ]
   ret i32* %retval.0
 }
 
-; CHECK: Function Attrs: nounwind
+; CHECK: Function Attrs: nofree nounwind
 ; CHECK-NEXT: define i32* @external_source_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
 define i32* @external_source_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %call = call i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   %call1 = call i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   ret i32* %call1
 }
 
 ; Verify that we see only expected attribute sets, the above lines only check
 ; for a subset relation.
 ;
 ; CHECK-NOT: attributes #
-; CHECK: attributes #{{.*}} = { nounwind }
-; CHECK: attributes #{{.*}} = { norecurse nounwind }
+; CHECK: attributes #{{.*}} = { nofree nounwind }
+; CHECK: attributes #{{.*}} = { nofree norecurse nounwind }
 ; CHECK-NOT: attributes #

llvm/trunk/test/Transforms/InferFunctionAttrs/annotate.ll

 ; RUN: opt < %s -mtriple=x86_64-- -inferattrs -S | FileCheck -check-prefix=CHECK-UNKNOWN %s
 ; RUN: opt < %s -mtriple=x86_64-- -passes=inferattrs -S | FileCheck -check-prefix=CHECK-UNKNOWN %s
 ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -inferattrs -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-DARWIN %s
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -inferattrs -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-LINUX %s
 ; RUN: opt < %s -mtriple=nvptx -inferattrs -S | FileCheck -check-prefix=CHECK-NVPTX %s
 
 ; operator new routines
-declare i8* @_Znwj(i64)
-; CHECK: declare noalias nonnull i8* @_Znwj(i64)
+declare i8* @_Znwj(i64 )
+; CHECK: declare noalias nonnull i8* @_Znwj(i64) [[G0:#[0-9]+]]
 declare i8* @_Znwm(i64)
-; CHECK: declare noalias nonnull i8* @_Znwm(i64)
+; CHECK: declare noalias nonnull i8* @_Znwm(i64) [[G0]]
 
 declare i32 @__nvvm_reflect(i8*)
 ; CHECK-NVPTX: declare i32 @__nvvm_reflect(i8*) [[G0:#[0-9]+]]
-; CHECK-NVPTX: attributes [[G0]] = { nounwind readnone }
+; CHECK-NVPTX: attributes [[G0]] = { nofree nounwind readnone }
 
 
 ; Check all the libc functions (thereby also exercising the prototype check).
 ; Note that it's OK to modify these as attributes might be missing. These checks
 ; reflect the currently inferred attributes.
 
 ; Use an opaque pointer type for all the (possibly opaque) structs.
 %opaque = type opaque

 declare x86_fp80 @__sinhl_finite(x86_fp80)
 
 ; CHECK: declare double @__sinpi(double)
 declare double @__sinpi(double)
 
 ; CHECK: declare float @__sinpif(float)
 declare float @__sinpif(float)
 
-; CHECK: declare i32 @abs(i32)
+; CHECK: declare i32 @abs(i32) [[G0]]
 declare i32 @abs(i32)
 
-; CHECK: declare i32 @access(i8* nocapture readonly, i32) [[G0:#[0-9]+]]
+; CHECK: declare i32 @access(i8* nocapture readonly, i32) [[G1:#[0-9]+]]
 declare i32 @access(i8*, i32)
 
-; CHECK: declare double @acos(double)
+; CHECK: declare double @acos(double) [[G0]]
 declare double @acos(double)
 
-; CHECK: declare float @acosf(float)
+; CHECK: declare float @acosf(float) [[G0]]
 declare float @acosf(float)
 
-; CHECK: declare double @acosh(double)
+; CHECK: declare double @acosh(double) [[G0]]
 declare double @acosh(double)
 
-; CHECK: declare float @acoshf(float)
+; CHECK: declare float @acoshf(float) [[G0]]
 declare float @acoshf(float)
 
-; CHECK: declare x86_fp80 @acoshl(x86_fp80)
+; CHECK: declare x86_fp80 @acoshl(x86_fp80) [[G0]]
 declare x86_fp80 @acoshl(x86_fp80)
 
-; CHECK: declare x86_fp80 @acosl(x86_fp80)
+; CHECK: declare x86_fp80 @acosl(x86_fp80) [[G0]]
 declare x86_fp80 @acosl(x86_fp80)
 
-; CHECK: declare double @asin(double)
+; CHECK: declare double @asin(double) [[G0]]
 declare double @asin(double)
 
-; CHECK: declare float @asinf(float)
+; CHECK: declare float @asinf(float) [[G0]]
 declare float @asinf(float)
 
-; CHECK: declare double @asinh(double)
+; CHECK: declare double @asinh(double) [[G0]]
 declare double @asinh(double)
 
-; CHECK: declare float @asinhf(float)
+; CHECK: declare float @asinhf(float) [[G0]]
 declare float @asinhf(float)
 
-; CHECK: declare x86_fp80 @asinhl(x86_fp80)
+; CHECK: declare x86_fp80 @asinhl(x86_fp80) [[G0]]
 declare x86_fp80 @asinhl(x86_fp80)
 
-; CHECK: declare x86_fp80 @asinl(x86_fp80)
+; CHECK: declare x86_fp80 @asinl(x86_fp80) [[G0]]
 declare x86_fp80 @asinl(x86_fp80)
 
-; CHECK: declare double @atan(double)
+; CHECK: declare double @atan(double) [[G0]]
 declare double @atan(double)
 
-; CHECK: declare double @atan2(double, double)
+; CHECK: declare double @atan2(double, double) [[G0]]
 declare double @atan2(double, double)
 
-; CHECK: declare float @atan2f(float, float)
+; CHECK: declare float @atan2f(float, float) [[G0]]
 declare float @atan2f(float, float)
 
-; CHECK: declare x86_fp80 @atan2l(x86_fp80, x86_fp80)
+; CHECK: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[G0]]
 declare x86_fp80 @atan2l(x86_fp80, x86_fp80)
 
-; CHECK: declare float @atanf(float)
+; CHECK: declare float @atanf(float) [[G0]]
 declare float @atanf(float)
 
-; CHECK: declare double @atanh(double)
+; CHECK: declare double @atanh(double) [[G0]]
 declare double @atanh(double)
 
-; CHECK: declare float @atanhf(float)
+; CHECK: declare float @atanhf(float) [[G0]]
 declare float @atanhf(float)
 
-; CHECK: declare x86_fp80 @atanhl(x86_fp80)
+; CHECK: declare x86_fp80 @atanhl(x86_fp80) [[G0]]
 declare x86_fp80 @atanhl(x86_fp80)
 
-; CHECK: declare x86_fp80 @atanl(x86_fp80)
+; CHECK: declare x86_fp80 @atanl(x86_fp80) [[G0]]
 declare x86_fp80 @atanl(x86_fp80)
 
-; CHECK: declare double @atof(i8* nocapture) [[G1:#[0-9]+]]
+; CHECK: declare double @atof(i8* nocapture) [[G2:#[0-9]+]]
 declare double @atof(i8*)
 
-; CHECK: declare i32 @atoi(i8* nocapture) [[G1]]
+; CHECK: declare i32 @atoi(i8* nocapture) [[G2]]
 declare i32 @atoi(i8*)
 
-; CHECK: declare i64 @atol(i8* nocapture) [[G1]]
+; CHECK: declare i64 @atol(i8* nocapture) [[G2]]
 declare i64 @atol(i8*)
 
-; CHECK: declare i64 @atoll(i8* nocapture) [[G1]]
+; CHECK: declare i64 @atoll(i8* nocapture) [[G2]]
 declare i64 @atoll(i8*)
 
-; CHECK-DARWIN: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G1]]
-; CHECK-LINUX: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G1]]
-; CHECK-UNKNOWN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G1]]
-; CHECK-NVPTX-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G1]]
+; CHECK-DARWIN: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
+; CHECK-LINUX: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
+; CHECK-UNKNOWN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
+; CHECK-NVPTX-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 declare i32 @bcmp(i8*, i8*, i64)
 
-; CHECK: declare void @bcopy(i8* nocapture readonly, i8* nocapture, i64) [[G0]]
+; CHECK: declare void @bcopy(i8* nocapture readonly, i8* nocapture, i64) [[G1]]
 declare void @bcopy(i8*, i8*, i64)
 
-; CHECK: declare void @bzero(i8* nocapture, i64) [[G0]]
+; CHECK: declare void @bzero(i8* nocapture, i64) [[G1]]
 declare void @bzero(i8*, i64)
 
-; CHECK: declare noalias i8* @calloc(i64, i64) [[G0]]
+; CHECK: declare noalias i8* @calloc(i64, i64) [[G1]]
 declare i8* @calloc(i64, i64)
 
-; CHECK: declare double @cbrt(double)
+; CHECK: declare double @cbrt(double) [[G0]]
 declare double @cbrt(double)
 
-; CHECK: declare float @cbrtf(float)
+; CHECK: declare float @cbrtf(float) [[G0]]
 declare float @cbrtf(float)
 
-; CHECK: declare x86_fp80 @cbrtl(x86_fp80)
+; CHECK: declare x86_fp80 @cbrtl(x86_fp80) [[G0]]
 declare x86_fp80 @cbrtl(x86_fp80)
 
-; CHECK: declare double @ceil(double)
+; CHECK: declare double @ceil(double) [[G0]]
 declare double @ceil(double)
 
-; CHECK: declare float @ceilf(float)
+; CHECK: declare float @ceilf(float) [[G0]]
 declare float @ceilf(float)
 
-; CHECK: declare x86_fp80 @ceill(x86_fp80)
+; CHECK: declare x86_fp80 @ceill(x86_fp80) [[G0]]
 declare x86_fp80 @ceill(x86_fp80)
 
-; CHECK: declare i32 @chmod(i8* nocapture readonly, i16 zeroext) [[G0]]
+; CHECK: declare i32 @chmod(i8* nocapture readonly, i16 zeroext) [[G1]]
 declare i32 @chmod(i8*, i16 zeroext)
 
-; CHECK: declare i32 @chown(i8* nocapture readonly, i32, i32) [[G0]]
+; CHECK: declare i32 @chown(i8* nocapture readonly, i32, i32) [[G1]]
 declare i32 @chown(i8*, i32, i32)
 
-; CHECK: declare void @clearerr(%opaque* nocapture) [[G0]]
+; CHECK: declare void @clearerr(%opaque* nocapture) [[G1]]
 declare void @clearerr(%opaque*)
 
-; CHECK: declare i32 @closedir(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @closedir(%opaque* nocapture) [[G1]]
 declare i32 @closedir(%opaque*)
 
-; CHECK: declare double @copysign(double, double)
+; CHECK: declare double @copysign(double, double) [[G0]]
 declare double @copysign(double, double)
 
-; CHECK: declare float @copysignf(float, float)
+; CHECK: declare float @copysignf(float, float) [[G0]]
 declare float @copysignf(float, float)
 
-; CHECK: declare x86_fp80 @copysignl(x86_fp80, x86_fp80)
+; CHECK: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) [[G0]]
 declare x86_fp80 @copysignl(x86_fp80, x86_fp80)
 
-; CHECK: declare double @cos(double)
+; CHECK: declare double @cos(double) [[G0]]
 declare double @cos(double)
 
-; CHECK: declare float @cosf(float)
+; CHECK: declare float @cosf(float) [[G0]]
 declare float @cosf(float)
 
-; CHECK: declare double @cosh(double)
+; CHECK: declare double @cosh(double) [[G0]]
 declare double @cosh(double)
 
-; CHECK: declare float @coshf(float)
+; CHECK: declare float @coshf(float) [[G0]]
 declare float @coshf(float)
 
-; CHECK: declare x86_fp80 @coshl(x86_fp80)
+; CHECK: declare x86_fp80 @coshl(x86_fp80) [[G0]]
 declare x86_fp80 @coshl(x86_fp80)
 
-; CHECK: declare x86_fp80 @cosl(x86_fp80)
+; CHECK: declare x86_fp80 @cosl(x86_fp80) [[G0]]
 declare x86_fp80 @cosl(x86_fp80)
 
-; CHECK: declare i8* @ctermid(i8* nocapture) [[G0]]
+; CHECK: declare i8* @ctermid(i8* nocapture) [[G1]]
 declare i8* @ctermid(i8*)
 
-; CHECK: declare double @exp(double)
+; CHECK: declare double @exp(double) [[G0]]
 declare double @exp(double)
 
-; CHECK: declare double @exp2(double)
+; CHECK: declare double @exp2(double) [[G0]]
 declare double @exp2(double)
 
-; CHECK: declare float @exp2f(float)
+; CHECK: declare float @exp2f(float) [[G0]]
 declare float @exp2f(float)
 
-; CHECK: declare x86_fp80 @exp2l(x86_fp80)
+; CHECK: declare x86_fp80 @exp2l(x86_fp80) [[G0]]
 declare x86_fp80 @exp2l(x86_fp80)
 
-; CHECK: declare float @expf(float)
+; CHECK: declare float @expf(float) [[G0]]
 declare float @expf(float)
 
-; CHECK: declare x86_fp80 @expl(x86_fp80)
+; CHECK: declare x86_fp80 @expl(x86_fp80) [[G0]]
 declare x86_fp80 @expl(x86_fp80)
 
-; CHECK: declare double @expm1(double)
+; CHECK: declare double @expm1(double) [[G0]]
 declare double @expm1(double)
 
-; CHECK: declare float @expm1f(float)
+; CHECK: declare float @expm1f(float) [[G0]]
 declare float @expm1f(float)
 
-; CHECK: declare x86_fp80 @expm1l(x86_fp80)
+; CHECK: declare x86_fp80 @expm1l(x86_fp80) [[G0]]
 declare x86_fp80 @expm1l(x86_fp80)
 
-; CHECK: declare double @fabs(double)
+; CHECK: declare double @fabs(double) [[G0]]
 declare double @fabs(double)
 
-; CHECK: declare float @fabsf(float)
+; CHECK: declare float @fabsf(float) [[G0]]
 declare float @fabsf(float)
 
-; CHECK: declare x86_fp80 @fabsl(x86_fp80)
+; CHECK: declare x86_fp80 @fabsl(x86_fp80) [[G0]]
 declare x86_fp80 @fabsl(x86_fp80)
 
-; CHECK: declare i32 @fclose(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fclose(%opaque* nocapture) [[G1]]
 declare i32 @fclose(%opaque*)
 
-; CHECK: declare noalias %opaque* @fdopen(i32, i8* nocapture readonly) [[G0]]
+; CHECK: declare noalias %opaque* @fdopen(i32, i8* nocapture readonly) [[G1]]
 declare %opaque* @fdopen(i32, i8*)
 
-; CHECK: declare i32 @feof(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @feof(%opaque* nocapture) [[G1]]
 declare i32 @feof(%opaque*)
 
-; CHECK: declare i32 @ferror(%opaque* nocapture) [[G1]]
+; CHECK: declare i32 @ferror(%opaque* nocapture) [[G2]]
 declare i32 @ferror(%opaque*)
 
-; CHECK: declare i32 @fflush(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fflush(%opaque* nocapture) [[G1]]
 declare i32 @fflush(%opaque*)
 
-; CHECK: declare i32 @ffs(i32)
+; CHECK: declare i32 @ffs(i32) [[G0]]
 declare i32 @ffs(i32)
 
-; CHECK: declare i32 @ffsl(i64)
+; CHECK: declare i32 @ffsl(i64) [[G0]]
 declare i32 @ffsl(i64)
 
-; CHECK: declare i32 @ffsll(i64)
+; CHECK: declare i32 @ffsll(i64) [[G0]]
 declare i32 @ffsll(i64)
 
-; CHECK: declare i32 @fgetc(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fgetc(%opaque* nocapture) [[G1]]
 declare i32 @fgetc(%opaque*)
 
-; CHECK: declare i32 @fgetpos(%opaque* nocapture, i64* nocapture) [[G0]]
+; CHECK: declare i32 @fgetpos(%opaque* nocapture, i64* nocapture) [[G1]]
 declare i32 @fgetpos(%opaque*, i64*)
 
-; CHECK: declare i8* @fgets(i8*, i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i8* @fgets(i8*, i32, %opaque* nocapture) [[G1]]
 declare i8* @fgets(i8*, i32, %opaque*)
 
-; CHECK: declare i32 @fileno(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fileno(%opaque* nocapture) [[G1]]
 declare i32 @fileno(%opaque*)
 
-; CHECK: declare void @flockfile(%opaque* nocapture) [[G0]]
+; CHECK: declare void @flockfile(%opaque* nocapture) [[G1]]
 declare void @flockfile(%opaque*)
 
-; CHECK: declare double @floor(double)
+; CHECK: declare double @floor(double) [[G0]]
 declare double @floor(double)
 
-; CHECK: declare float @floorf(float)
+; CHECK: declare float @floorf(float) [[G0]]
 declare float @floorf(float)
 
-; CHECK: declare x86_fp80 @floorl(x86_fp80)
+; CHECK: declare x86_fp80 @floorl(x86_fp80) [[G0]]
 declare x86_fp80 @floorl(x86_fp80)
 
 ; CHECK: declare i32 @fls(i32)
 declare i32 @fls(i32)
 
 ; CHECK: declare i32 @flsl(i64)
 declare i32 @flsl(i64)
 
 ; CHECK: declare i32 @flsll(i64)
 declare i32 @flsll(i64)
 
-; CHECK: declare double @fmax(double, double)
+; CHECK: declare double @fmax(double, double) [[G0]]
 declare double @fmax(double, double)
 
-; CHECK: declare float @fmaxf(float, float)
+; CHECK: declare float @fmaxf(float, float) [[G0]]
 declare float @fmaxf(float, float)
 
-; CHECK: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80)
+; CHECK: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) [[G0]]
 declare x86_fp80 @fmaxl(x86_fp80, x86_fp80)
 
-; CHECK: declare double @fmin(double, double)
+; CHECK: declare double @fmin(double, double) [[G0]]
 declare double @fmin(double, double)
 
-; CHECK: declare float @fminf(float, float)
+; CHECK: declare float @fminf(float, float) [[G0]]
 declare float @fminf(float, float)
 
-; CHECK: declare x86_fp80 @fminl(x86_fp80, x86_fp80)
+; CHECK: declare x86_fp80 @fminl(x86_fp80, x86_fp80) [[G0]]
 declare x86_fp80 @fminl(x86_fp80, x86_fp80)
 
-; CHECK: declare double @fmod(double, double)
+; CHECK: declare double @fmod(double, double) [[G0]]
 declare double @fmod(double, double)
 
-; CHECK: declare float @fmodf(float, float)
+; CHECK: declare float @fmodf(float, float) [[G0]]
 declare float @fmodf(float, float)
 
-; CHECK: declare x86_fp80 @fmodl(x86_fp80, x86_fp80)
+; CHECK: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[G0]]
 declare x86_fp80 @fmodl(x86_fp80, x86_fp80)
 
-; CHECK: declare noalias %opaque* @fopen(i8* nocapture readonly, i8* nocapture readonly) [[G0]]
+; CHECK: declare noalias %opaque* @fopen(i8* nocapture readonly, i8* nocapture readonly) [[G1]]
 declare %opaque* @fopen(i8*, i8*)
 
-; CHECK: declare i32 @fprintf(%opaque* nocapture, i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @fprintf(%opaque* nocapture, i8* nocapture readonly, ...) [[G1]]
 declare i32 @fprintf(%opaque*, i8*, ...)
 
-; CHECK: declare i32 @fputc(i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fputc(i32, %opaque* nocapture) [[G1]]
 declare i32 @fputc(i32, %opaque*)
 
-; CHECK: declare i32 @fputs(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fputs(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @fputs(i8*, %opaque*)
 
-; CHECK: declare i64 @fread(i8* nocapture, i64, i64, %opaque* nocapture) [[G0]]
+; CHECK: declare i64 @fread(i8* nocapture, i64, i64, %opaque* nocapture) [[G1]]
 declare i64 @fread(i8*, i64, i64, %opaque*)
 
-; CHECK: declare void @free(i8* nocapture) [[G0]]
+; CHECK: declare void @free(i8* nocapture) [[G3:#[0-9]+]]
 declare void @free(i8*)
 
-; CHECK: declare double @frexp(double, i32* nocapture) [[G0]]
+; CHECK: declare double @frexp(double, i32* nocapture) [[G1]]
 declare double @frexp(double, i32*)
 
-; CHECK: declare float @frexpf(float, i32* nocapture) [[G0]]
+; CHECK: declare float @frexpf(float, i32* nocapture) [[G1]]
 declare float @frexpf(float, i32*)
 
-; CHECK: declare x86_fp80 @frexpl(x86_fp80, i32* nocapture) [[G0]]
+; CHECK: declare x86_fp80 @frexpl(x86_fp80, i32* nocapture) [[G1]]
 declare x86_fp80 @frexpl(x86_fp80, i32*)
 
-; CHECK: declare i32 @fscanf(%opaque* nocapture, i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @fscanf(%opaque* nocapture, i8* nocapture readonly, ...) [[G1]]
 declare i32 @fscanf(%opaque*, i8*, ...)
 
-; CHECK: declare i32 @fseek(%opaque* nocapture, i64, i32) [[G0]]
+; CHECK: declare i32 @fseek(%opaque* nocapture, i64, i32) [[G1]]
 declare i32 @fseek(%opaque*, i64, i32)
 
-; CHECK: declare i32 @fseeko(%opaque* nocapture, i64, i32) [[G0]]
+; CHECK: declare i32 @fseeko(%opaque* nocapture, i64, i32) [[G1]]
 declare i32 @fseeko(%opaque*, i64, i32)
 
-; CHECK-LINUX: declare i32 @fseeko64(%opaque* nocapture, i64, i32) [[G0]]
+; CHECK-LINUX: declare i32 @fseeko64(%opaque* nocapture, i64, i32) [[G1]]
 declare i32 @fseeko64(%opaque*, i64, i32)
 
-; CHECK: declare i32 @fsetpos(%opaque* nocapture, i64*) [[G0]]
+; CHECK: declare i32 @fsetpos(%opaque* nocapture, i64*) [[G1]]
 declare i32 @fsetpos(%opaque*, i64*)
 
-; CHECK: declare i32 @fstat(i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fstat(i32, %opaque* nocapture) [[G1]]
 declare i32 @fstat(i32, %opaque*)
 
-; CHECK-LINUX: declare i32 @fstat64(i32, %opaque* nocapture) [[G0]]
+; CHECK-LINUX: declare i32 @fstat64(i32, %opaque* nocapture) [[G1]]
 declare i32 @fstat64(i32, %opaque*)
 
-; CHECK: declare i32 @fstatvfs(i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @fstatvfs(i32, %opaque* nocapture) [[G1]]
 declare i32 @fstatvfs(i32, %opaque*)
 
-; CHECK-LINUX: declare i32 @fstatvfs64(i32, %opaque* nocapture) [[G0]]
+; CHECK-LINUX: declare i32 @fstatvfs64(i32, %opaque* nocapture) [[G1]]
 declare i32 @fstatvfs64(i32, %opaque*)
 
-; CHECK: declare i64 @ftell(%opaque* nocapture) [[G0]]
+; CHECK: declare i64 @ftell(%opaque* nocapture) [[G1]]
 declare i64 @ftell(%opaque*)
 
-; CHECK: declare i64 @ftello(%opaque* nocapture) [[G0]]
+; CHECK: declare i64 @ftello(%opaque* nocapture) [[G1]]
 declare i64 @ftello(%opaque*)
 
-; CHECK-LINUX: declare i64 @ftello64(%opaque* nocapture) [[G0]]
+; CHECK-LINUX: declare i64 @ftello64(%opaque* nocapture) [[G1]]
 declare i64 @ftello64(%opaque*)
 
-; CHECK: declare i32 @ftrylockfile(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @ftrylockfile(%opaque* nocapture) [[G1]]
 declare i32 @ftrylockfile(%opaque*)
 
-; CHECK: declare void @funlockfile(%opaque* nocapture) [[G0]]
+; CHECK: declare void @funlockfile(%opaque* nocapture) [[G1]]
 declare void @funlockfile(%opaque*)
 
-; CHECK: declare i64 @fwrite(i8* nocapture, i64, i64, %opaque* nocapture) [[G0]]
+; CHECK: declare i64 @fwrite(i8* nocapture, i64, i64, %opaque* nocapture) [[G1]]
 declare i64 @fwrite(i8*, i64, i64, %opaque*)
 
-; CHECK: declare i32 @getc(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @getc(%opaque* nocapture) [[G1]]
 declare i32 @getc(%opaque*)
 
-; CHECK: declare i32 @getc_unlocked(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @getc_unlocked(%opaque* nocapture) [[G1]]
 declare i32 @getc_unlocked(%opaque*)
 
-; CHECK: declare i32 @getchar()
+; CHECK: declare i32 @getchar() [[G1]]
 declare i32 @getchar()
 
-; CHECK: declare i32 @getchar_unlocked()
+; CHECK: declare i32 @getchar_unlocked() [[G1]]
 declare i32 @getchar_unlocked()
 
-; CHECK: declare i8* @getenv(i8* nocapture) [[G1]]
+; CHECK: declare i8* @getenv(i8* nocapture) [[G2]]
 declare i8* @getenv(i8*)
 
-; CHECK: declare i32 @getitimer(i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @getitimer(i32, %opaque* nocapture) [[G1]]
 declare i32 @getitimer(i32, %opaque*)
 
-; CHECK: declare i32 @getlogin_r(i8* nocapture, i64) [[G0]]
+; CHECK: declare i32 @getlogin_r(i8* nocapture, i64) [[G1]]
 declare i32 @getlogin_r(i8*, i64)
 
-; CHECK: declare %opaque* @getpwnam(i8* nocapture readonly) [[G0]]
+; CHECK: declare %opaque* @getpwnam(i8* nocapture readonly) [[G1]]
 declare %opaque* @getpwnam(i8*)
 
-; CHECK: declare i8* @gets(i8*)
+; CHECK: declare i8* @gets(i8*) [[G1]]
 declare i8* @gets(i8*)
 
-; CHECK: declare i32 @gettimeofday(%opaque* nocapture, i8* nocapture) [[G0]]
+; CHECK: declare i32 @gettimeofday(%opaque* nocapture, i8* nocapture) [[G1]]
 declare i32 @gettimeofday(%opaque*, i8*)
 
-; CHECK: declare i32 @isascii(i32)
+; CHECK: declare i32 @isascii(i32) [[G0]]
 declare i32 @isascii(i32)
 
-; CHECK: declare i32 @isdigit(i32)
+; CHECK: declare i32 @isdigit(i32) [[G0]]
 declare i32 @isdigit(i32)
 
-; CHECK: declare i64 @labs(i64)
+; CHECK: declare i64 @labs(i64) [[G0]]
 declare i64 @labs(i64)
 
-; CHECK: declare i32 @lchown(i8* nocapture readonly, i32, i32) [[G0]]
+; CHECK: declare i32 @lchown(i8* nocapture readonly, i32, i32) [[G1]]
 declare i32 @lchown(i8*, i32, i32)
 
-; CHECK: declare double @ldexp(double, i32)
+; CHECK: declare double @ldexp(double, i32) [[G0]]
 declare double @ldexp(double, i32)
 
-; CHECK: declare float @ldexpf(float, i32)
+; CHECK: declare float @ldexpf(float, i32) [[G0]]
 declare float @ldexpf(float, i32)
 
-; CHECK: declare x86_fp80 @ldexpl(x86_fp80, i32)
+; CHECK: declare x86_fp80 @ldexpl(x86_fp80, i32) [[G0]]
 declare x86_fp80 @ldexpl(x86_fp80, i32)
 
-; CHECK: declare i64 @llabs(i64)
+; CHECK: declare i64 @llabs(i64) [[G0]]
 declare i64 @llabs(i64)
 
-; CHECK: declare double @log(double)
+; CHECK: declare double @log(double) [[G0]]
 declare double @log(double)
 
-; CHECK: declare double @log10(double)
+; CHECK: declare double @log10(double) [[G0]]
 declare double @log10(double)
 
-; CHECK: declare float @log10f(float)
+; CHECK: declare float @log10f(float) [[G0]]
 declare float @log10f(float)
 
-; CHECK: declare x86_fp80 @log10l(x86_fp80)
+; CHECK: declare x86_fp80 @log10l(x86_fp80) [[G0]]
 declare x86_fp80 @log10l(x86_fp80)
 
-; CHECK: declare double @log1p(double)
+; CHECK: declare double @log1p(double) [[G0]]
 declare double @log1p(double)
 
-; CHECK: declare float @log1pf(float)
+; CHECK: declare float @log1pf(float) [[G0]]
 declare float @log1pf(float)
 
-; CHECK: declare x86_fp80 @log1pl(x86_fp80)
+; CHECK: declare x86_fp80 @log1pl(x86_fp80) [[G0]]
 declare x86_fp80 @log1pl(x86_fp80)
 
-; CHECK: declare double @log2(double)
+; CHECK: declare double @log2(double) [[G0]]
 declare double @log2(double)
 
-; CHECK: declare float @log2f(float)
+; CHECK: declare float @log2f(float) [[G0]]
 declare float @log2f(float)
 
-; CHECK: declare x86_fp80 @log2l(x86_fp80)
+; CHECK: declare x86_fp80 @log2l(x86_fp80) [[G0]]
 declare x86_fp80 @log2l(x86_fp80)
 
-; CHECK: declare double @logb(double)
+; CHECK: declare double @logb(double) [[G0]]
 declare double @logb(double)
 
-; CHECK: declare float @logbf(float)
+; CHECK: declare float @logbf(float) [[G0]]
 declare float @logbf(float)
 
-; CHECK: declare x86_fp80 @logbl(x86_fp80)
+; CHECK: declare x86_fp80 @logbl(x86_fp80) [[G0]]
 declare x86_fp80 @logbl(x86_fp80)
 
-; CHECK: declare float @logf(float)
+; CHECK: declare float @logf(float) [[G0]]
 declare float @logf(float)
 
-; CHECK: declare x86_fp80 @logl(x86_fp80)
+; CHECK: declare x86_fp80 @logl(x86_fp80) [[G0]]
 declare x86_fp80 @logl(x86_fp80)
 
-; CHECK: declare i32 @lstat(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @lstat(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @lstat(i8*, %opaque*)
 
-; CHECK-LINUX: declare i32 @lstat64(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK-LINUX: declare i32 @lstat64(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @lstat64(i8*, %opaque*)
 
-; CHECK: declare noalias i8* @malloc(i64) [[G0]]
+; CHECK: declare noalias i8* @malloc(i64) [[G1]]
 declare i8* @malloc(i64)
 
-; CHECK-LINUX: declare noalias i8* @memalign(i64, i64)
+; CHECK-LINUX: declare noalias i8* @memalign(i64, i64) [[G0]]
 declare i8* @memalign(i64, i64)
 
-; CHECK: declare i8* @memccpy(i8*, i8* nocapture readonly, i32, i64) [[G0]]
+; CHECK: declare i8* @memccpy(i8*, i8* nocapture readonly, i32, i64) [[G1]]
 declare i8* @memccpy(i8*, i8*, i32, i64)
 
-; CHECK: declare i8* @memchr(i8*, i32, i64) [[G1]]
+; CHECK: declare i8* @memchr(i8*, i32, i64) [[G2]]
 declare i8* @memchr(i8*, i32, i64)
 
-; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[G1]]
+; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 declare i32 @memcmp(i8*, i8*, i64)
 
-; CHECK: declare i8* @memcpy(i8* returned, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i8* @memcpy(i8* returned, i8* nocapture readonly, i64) [[G1]]
 declare i8* @memcpy(i8*, i8*, i64)
 
-; CHECK: declare i8* @mempcpy(i8*, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i8* @mempcpy(i8*, i8* nocapture readonly, i64) [[G1]]
 declare i8* @mempcpy(i8*, i8*, i64)
 
-; CHECK: declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) [[G1]]
 declare i8* @memmove(i8*, i8*, i64)
 
-; CHECK: declare i8* @memset(i8*, i32, i64)
+; CHECK: declare i8* @memset(i8*, i32, i64) [[G0]]
 declare i8* @memset(i8*, i32, i64)
 
-; CHECK: declare i32 @mkdir(i8* nocapture readonly, i16 zeroext) [[G0]]
+; CHECK: declare i32 @mkdir(i8* nocapture readonly, i16 zeroext) [[G1]]
 declare i32 @mkdir(i8*, i16 zeroext)
 
-; CHECK: declare i64 @mktime(%opaque* nocapture) [[G0]]
+; CHECK: declare i64 @mktime(%opaque* nocapture) [[G1]]
 declare i64 @mktime(%opaque*)
 
-; CHECK: declare double @modf(double, double* nocapture) [[G0]]
+; CHECK: declare double @modf(double, double* nocapture) [[G1]]
 declare double @modf(double, double*)
 
-; CHECK: declare float @modff(float, float* nocapture) [[G0]]
+; CHECK: declare float @modff(float, float* nocapture) [[G1]]
 declare float @modff(float, float*)
 
-; CHECK: declare x86_fp80 @modfl(x86_fp80, x86_fp80* nocapture) [[G0]]
+; CHECK: declare x86_fp80 @modfl(x86_fp80, x86_fp80* nocapture) [[G1]]
 declare x86_fp80 @modfl(x86_fp80, x86_fp80*)
 
-; CHECK: declare double @nearbyint(double)
+; CHECK: declare double @nearbyint(double) [[G0]]
 declare double @nearbyint(double)
 
-; CHECK: declare float @nearbyintf(float)
+; CHECK: declare float @nearbyintf(float) [[G0]]
 declare float @nearbyintf(float)
 
-; CHECK: declare x86_fp80 @nearbyintl(x86_fp80)
+; CHECK: declare x86_fp80 @nearbyintl(x86_fp80) [[G0]]
 declare x86_fp80 @nearbyintl(x86_fp80)
 
-; CHECK: declare i32 @open(i8* nocapture readonly, i32, ...)
+; CHECK: declare i32 @open(i8* nocapture readonly, i32, ...) [[G0]]
 declare i32 @open(i8*, i32, ...)
 
-; CHECK-LINUX: declare i32 @open64(i8* nocapture readonly, i32, ...)
+; CHECK-LINUX: declare i32 @open64(i8* nocapture readonly, i32, ...) [[G0]]
 declare i32 @open64(i8*, i32, ...)
 
-; CHECK: declare noalias %opaque* @opendir(i8* nocapture readonly) [[G0]]
+; CHECK: declare noalias %opaque* @opendir(i8* nocapture readonly) [[G1]]
 declare %opaque* @opendir(i8*)
 
-; CHECK: declare i32 @pclose(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @pclose(%opaque* nocapture) [[G1]]
 declare i32 @pclose(%opaque*)
 
-; CHECK: declare void @perror(i8* nocapture readonly) [[G0]]
+; CHECK: declare void @perror(i8* nocapture readonly) [[G1]]
 declare void @perror(i8*)
 
-; CHECK: declare noalias %opaque* @popen(i8* nocapture readonly, i8* nocapture readonly) [[G0]]
+; CHECK: declare noalias %opaque* @popen(i8* nocapture readonly, i8* nocapture readonly) [[G1]]
 declare %opaque* @popen(i8*, i8*)
 
-; CHECK: declare i32 @posix_memalign(i8**, i64, i64)
+; CHECK: declare i32 @posix_memalign(i8**, i64, i64) [[G0]]
 declare i32 @posix_memalign(i8**, i64, i64)
 
-; CHECK: declare double @pow(double, double)
+; CHECK: declare double @pow(double, double) [[G0]]
 declare double @pow(double, double)
 
-; CHECK: declare float @powf(float, float)
+; CHECK: declare float @powf(float, float) [[G0]]
 declare float @powf(float, float)
 
-; CHECK: declare x86_fp80 @powl(x86_fp80, x86_fp80)
+; CHECK: declare x86_fp80 @powl(x86_fp80, x86_fp80) [[G0]]
 declare x86_fp80 @powl(x86_fp80, x86_fp80)
 
-; CHECK: declare i64 @pread(i32, i8* nocapture, i64, i64)
+; CHECK: declare i64 @pread(i32, i8* nocapture, i64, i64) [[G0]]
 declare i64 @pread(i32, i8*, i64, i64)
 
-; CHECK: declare i32 @printf(i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @printf(i8* nocapture readonly, ...) [[G1]]
 declare i32 @printf(i8*, ...)
 
-; CHECK: declare i32 @putc(i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @putc(i32, %opaque* nocapture) [[G1]]
 declare i32 @putc(i32, %opaque*)
 
-; CHECK: declare i32 @putchar(i32)
+; CHECK: declare i32 @putchar(i32) [[G1]]
 declare i32 @putchar(i32)
 
-; CHECK: declare i32 @putchar_unlocked(i32)
+; CHECK: declare i32 @putchar_unlocked(i32) [[G1]]
 declare i32 @putchar_unlocked(i32)
 
-; CHECK: declare i32 @puts(i8* nocapture readonly) [[G0]]
+; CHECK: declare i32 @puts(i8* nocapture readonly) [[G1]]
 declare i32 @puts(i8*)
 
-; CHECK: declare i64 @pwrite(i32, i8* nocapture readonly, i64, i64)
+; CHECK: declare i64 @pwrite(i32, i8* nocapture readonly, i64, i64) [[G0]]
 declare i64 @pwrite(i32, i8*, i64, i64)
 
-; CHECK: declare void @qsort(i8*, i64, i64, i32 (i8*, i8*)* nocapture)
+; CHECK: declare void @qsort(i8*, i64, i64, i32 (i8*, i8*)* nocapture) [[G0]]
 declare void @qsort(i8*, i64, i64, i32 (i8*, i8*)*)
 
-; CHECK: declare i64 @read(i32, i8* nocapture, i64)
+; CHECK: declare i64 @read(i32, i8* nocapture, i64) [[G0]]
 declare i64 @read(i32, i8*, i64)
 
-; CHECK: declare i64 @readlink(i8* nocapture readonly, i8* nocapture, i64) [[G0]]
+; CHECK: declare i64 @readlink(i8* nocapture readonly, i8* nocapture, i64) [[G1]]
 declare i64 @readlink(i8*, i8*, i64)
 
-; CHECK: declare noalias i8* @realloc(i8* nocapture, i64) [[G0]]
+; CHECK: declare noalias i8* @realloc(i8* nocapture, i64) [[G3]]
 declare i8* @realloc(i8*, i64)
 
 ; CHECK: declare i8* @reallocf(i8*, i64)
 declare i8* @reallocf(i8*, i64)
 
-; CHECK: declare i8* @realpath(i8* nocapture readonly, i8*)
+; CHECK: declare i8* @realpath(i8* nocapture readonly, i8*) [[G1]]
 declare i8* @realpath(i8*, i8*)
 
-; CHECK: declare i32 @remove(i8* nocapture readonly) [[G0]]
+; CHECK: declare i32 @remove(i8* nocapture readonly) [[G1]]
 declare i32 @remove(i8*)
 
-; CHECK: declare i32 @rename(i8* nocapture readonly, i8* nocapture readonly) [[G0]]
+; CHECK: declare i32 @rename(i8* nocapture readonly, i8* nocapture readonly) [[G1]]
 declare i32 @rename(i8*, i8*)
 
-; CHECK: declare void @rewind(%opaque* nocapture) [[G0]]
+; CHECK: declare void @rewind(%opaque* nocapture) [[G1]]
 declare void @rewind(%opaque*)
 
-; CHECK: declare double @rint(double)
+; CHECK: declare double @rint(double) [[G0]]
 declare double @rint(double)
 
-; CHECK: declare float @rintf(float)
+; CHECK: declare float @rintf(float) [[G0]]
 declare float @rintf(float)
 
-; CHECK: declare x86_fp80 @rintl(x86_fp80)
+; CHECK: declare x86_fp80 @rintl(x86_fp80) [[G0]]
 declare x86_fp80 @rintl(x86_fp80)
 
-; CHECK: declare i32 @rmdir(i8* nocapture readonly) [[G0]]
+; CHECK: declare i32 @rmdir(i8* nocapture readonly) [[G1]]
 declare i32 @rmdir(i8*)
 
-; CHECK: declare double @round(double)
+; CHECK: declare double @round(double) [[G0]]
 declare double @round(double)
 
-; CHECK: declare float @roundf(float)
+; CHECK: declare float @roundf(float) [[G0]]
 declare float @roundf(float)
 
-; CHECK: declare x86_fp80 @roundl(x86_fp80)
+; CHECK: declare x86_fp80 @roundl(x86_fp80) [[G0]]
 declare x86_fp80 @roundl(x86_fp80)
 
-; CHECK: declare i32 @scanf(i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @scanf(i8* nocapture readonly, ...) [[G1]]
 declare i32 @scanf(i8*, ...)
 
-; CHECK: declare void @setbuf(%opaque* nocapture, i8*) [[G0]]
+; CHECK: declare void @setbuf(%opaque* nocapture, i8*) [[G1]]
 declare void @setbuf(%opaque*, i8*)
 
-; CHECK: declare i32 @setitimer(i32, %opaque* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @setitimer(i32, %opaque* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @setitimer(i32, %opaque*, %opaque*)
 
-; CHECK: declare i32 @setvbuf(%opaque* nocapture, i8*, i32, i64) [[G0]]
+; CHECK: declare i32 @setvbuf(%opaque* nocapture, i8*, i32, i64) [[G1]]
 declare i32 @setvbuf(%opaque*, i8*, i32, i64)
 
-; CHECK: declare double @sin(double)
+; CHECK: declare double @sin(double) [[G0]]
 declare double @sin(double)
 
-; CHECK: declare float @sinf(float)
+; CHECK: declare float @sinf(float) [[G0]]
 declare float @sinf(float)
 
-; CHECK: declare double @sinh(double)
+; CHECK: declare double @sinh(double) [[G0]]
 declare double @sinh(double)
 
-; CHECK: declare float @sinhf(float)
+; CHECK: declare float @sinhf(float) [[G0]]
 declare float @sinhf(float)
 
-; CHECK: declare x86_fp80 @sinhl(x86_fp80)
+; CHECK: declare x86_fp80 @sinhl(x86_fp80) [[G0]]
 declare x86_fp80 @sinhl(x86_fp80)
 
-; CHECK: declare x86_fp80 @sinl(x86_fp80)
+; CHECK: declare x86_fp80 @sinl(x86_fp80) [[G0]]
 declare x86_fp80 @sinl(x86_fp80)
 
-; CHECK: declare i32 @snprintf(i8* nocapture, i64, i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @snprintf(i8* nocapture, i64, i8* nocapture readonly, ...) [[G1]]
 declare i32 @snprintf(i8*, i64, i8*, ...)
 
-; CHECK: declare i32 @sprintf(i8* nocapture, i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @sprintf(i8* nocapture, i8* nocapture readonly, ...) [[G1]]
 declare i32 @sprintf(i8*, i8*, ...)
 
-; CHECK: declare double @sqrt(double)
+; CHECK: declare double @sqrt(double) [[G0]]
 declare double @sqrt(double)
 
-; CHECK: declare float @sqrtf(float)
+; CHECK: declare float @sqrtf(float) [[G0]]
 declare float @sqrtf(float)
 
-; CHECK: declare x86_fp80 @sqrtl(x86_fp80)
+; CHECK: declare x86_fp80 @sqrtl(x86_fp80) [[G0]]
 declare x86_fp80 @sqrtl(x86_fp80)
 
-; CHECK: declare i32 @sscanf(i8* nocapture readonly, i8* nocapture readonly, ...) [[G0]]
+; CHECK: declare i32 @sscanf(i8* nocapture readonly, i8* nocapture readonly, ...) [[G1]]
 declare i32 @sscanf(i8*, i8*, ...)
 
-; CHECK: declare i32 @stat(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @stat(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @stat(i8*, %opaque*)
 
-; CHECK-LINUX: declare i32 @stat64(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK-LINUX: declare i32 @stat64(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @stat64(i8*, %opaque*)
 
-; CHECK: declare i32 @statvfs(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @statvfs(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @statvfs(i8*, %opaque*)
 
-; CHECK-LINUX: declare i32 @statvfs64(i8* nocapture readonly, %opaque* nocapture) [[G0]]
+; CHECK-LINUX: declare i32 @statvfs64(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 declare i32 @statvfs64(i8*, %opaque*)
 
-; CHECK: declare i8* @stpcpy(i8*, i8* nocapture readonly) [[G0]]
+; CHECK: declare i8* @stpcpy(i8*, i8* nocapture readonly) [[G1]]
 declare i8* @stpcpy(i8*, i8*)
 
-; CHECK: declare i8* @stpncpy(i8*, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i8* @stpncpy(i8*, i8* nocapture readonly, i64) [[G1]]
 declare i8* @stpncpy(i8*, i8*, i64)
 
-; CHECK: declare i32 @strcasecmp(i8* nocapture, i8* nocapture) [[G1]]
+; CHECK: declare i32 @strcasecmp(i8* nocapture, i8* nocapture) [[G2]]
 declare i32 @strcasecmp(i8*, i8*)
 
-; CHECK: declare i8* @strcat(i8* returned, i8* nocapture readonly) [[G0]]
+; CHECK: declare i8* @strcat(i8* returned, i8* nocapture readonly) [[G1]]
 declare i8* @strcat(i8*, i8*)
 
-; CHECK: declare i8* @strchr(i8*, i32) [[G1]]
+; CHECK: declare i8* @strchr(i8*, i32) [[G2]]
 declare i8* @strchr(i8*, i32)
 
-; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[G1]]
+; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[G2]]
 declare i32 @strcmp(i8*, i8*)
 
-; CHECK: declare i32 @strcoll(i8* nocapture, i8* nocapture) [[G1]]
+; CHECK: declare i32 @strcoll(i8* nocapture, i8* nocapture) [[G2]]
 declare i32 @strcoll(i8*, i8*)
 
-; CHECK: declare i8* @strcpy(i8* returned, i8* nocapture readonly) [[G0]]
+; CHECK: declare i8* @strcpy(i8* returned, i8* nocapture readonly) [[G1]]
 declare i8* @strcpy(i8*, i8*)
 
-; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[G1]]
+; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[G2]]
 declare i64 @strcspn(i8*, i8*)
 
-; CHECK: declare noalias i8* @strdup(i8* nocapture readonly) [[G0]]
+; CHECK: declare noalias i8* @strdup(i8* nocapture readonly) [[G1]]
 declare i8* @strdup(i8*)
 
-; CHECK: declare i64 @strlen(i8* nocapture) [[G2:#[0-9]+]]
+; CHECK: declare i64 @strlen(i8* nocapture) [[G4:#[0-9]+]]
 declare i64 @strlen(i8*)
 
-; CHECK: declare i32 @strncasecmp(i8* nocapture, i8* nocapture, i64) [[G1]]
+; CHECK: declare i32 @strncasecmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 declare i32 @strncasecmp(i8*, i8*, i64)
 
-; CHECK: declare i8* @strncat(i8* returned, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i8* @strncat(i8* returned, i8* nocapture readonly, i64) [[G1]]
 declare i8* @strncat(i8*, i8*, i64)
 
-; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[G1]]
+; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 declare i32 @strncmp(i8*, i8*, i64)
 
-; CHECK: declare i8* @strncpy(i8* returned, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i8* @strncpy(i8* returned, i8* nocapture readonly, i64) [[G1]]
 declare i8* @strncpy(i8*, i8*, i64)
 
-; CHECK: declare noalias i8* @strndup(i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare noalias i8* @strndup(i8* nocapture readonly, i64) [[G1]]
 declare i8* @strndup(i8*, i64)
 
-; CHECK: declare i64 @strnlen(i8*, i64)
+; CHECK: declare i64 @strnlen(i8*, i64) [[G0]]
 declare i64 @strnlen(i8*, i64)
 
-; CHECK: declare i8* @strpbrk(i8*, i8* nocapture) [[G1]]
+; CHECK: declare i8* @strpbrk(i8*, i8* nocapture) [[G2]]
 declare i8* @strpbrk(i8*, i8*)
 
-; CHECK: declare i8* @strrchr(i8*, i32) [[G1]]
+; CHECK: declare i8* @strrchr(i8*, i32) [[G2]]
 declare i8* @strrchr(i8*, i32)
 
-; CHECK: declare i64 @strspn(i8* nocapture, i8* nocapture) [[G1]]
+; CHECK: declare i64 @strspn(i8* nocapture, i8* nocapture) [[G2]]
 declare i64 @strspn(i8*, i8*)
 
-; CHECK: declare i8* @strstr(i8*, i8* nocapture) [[G1]]
+; CHECK: declare i8* @strstr(i8*, i8* nocapture) [[G2]]
 declare i8* @strstr(i8*, i8*)
 
-; CHECK: declare double @strtod(i8* readonly, i8** nocapture) [[G0]]
+; CHECK: declare double @strtod(i8* readonly, i8** nocapture) [[G1]]
 declare double @strtod(i8*, i8**)
 
-; CHECK: declare float @strtof(i8* readonly, i8** nocapture) [[G0]]
+; CHECK: declare float @strtof(i8* readonly, i8** nocapture) [[G1]]
 declare float @strtof(i8*, i8**)
 
-; CHECK: declare i8* @strtok(i8*, i8* nocapture readonly) [[G0]]
+; CHECK: declare i8* @strtok(i8*, i8* nocapture readonly) [[G1]]
 declare i8* @strtok(i8*, i8*)
 
-; CHECK: declare i8* @strtok_r(i8*, i8* nocapture readonly, i8**) [[G0]]
+; CHECK: declare i8* @strtok_r(i8*, i8* nocapture readonly, i8**) [[G1]]
 declare i8* @strtok_r(i8*, i8*, i8**)
 
-; CHECK: declare i64 @strtol(i8* readonly, i8** nocapture, i32) [[G0]]
+; CHECK: declare i64 @strtol(i8* readonly, i8** nocapture, i32) [[G1]]
 declare i64 @strtol(i8*, i8**, i32)
 
-; CHECK: declare x86_fp80 @strtold(i8* readonly, i8** nocapture) [[G0]]
+; CHECK: declare x86_fp80 @strtold(i8* readonly, i8** nocapture) [[G1]]
 declare x86_fp80 @strtold(i8*, i8**)
 
-; CHECK: declare i64 @strtoll(i8* readonly, i8** nocapture, i32) [[G0]]
+; CHECK: declare i64 @strtoll(i8* readonly, i8** nocapture, i32) [[G1]]
 declare i64 @strtoll(i8*, i8**, i32)
 
-; CHECK: declare i64 @strtoul(i8* readonly, i8** nocapture, i32) [[G0]]
+; CHECK: declare i64 @strtoul(i8* readonly, i8** nocapture, i32) [[G1]]
 declare i64 @strtoul(i8*, i8**, i32)
 
-; CHECK: declare i64 @strtoull(i8* readonly, i8** nocapture, i32) [[G0]]
+; CHECK: declare i64 @strtoull(i8* readonly, i8** nocapture, i32) [[G1]]
 declare i64 @strtoull(i8*, i8**, i32)
 
-; CHECK: declare i64 @strxfrm(i8* nocapture, i8* nocapture readonly, i64) [[G0]]
+; CHECK: declare i64 @strxfrm(i8* nocapture, i8* nocapture readonly, i64) [[G1]]
 declare i64 @strxfrm(i8*, i8*, i64)
 
-; CHECK: declare i32 @system(i8* nocapture readonly)
+; CHECK: declare i32 @system(i8* nocapture readonly) [[G0]]
 declare i32 @system(i8*)
 
-; CHECK: declare double @tan(double)
+; CHECK: declare double @tan(double) [[G0]]
 declare double @tan(double)
 
-; CHECK: declare float @tanf(float)
+; CHECK: declare float @tanf(float) [[G0]]
 declare float @tanf(float)
 
-; CHECK: declare double @tanh(double)
+; CHECK: declare double @tanh(double) [[G0]]
 declare double @tanh(double)
 
-; CHECK: declare float @tanhf(float)
+; CHECK: declare float @tanhf(float) [[G0]]
 declare float @tanhf(float)
 
-; CHECK: declare x86_fp80 @tanhl(x86_fp80)
+; CHECK: declare x86_fp80 @tanhl(x86_fp80) [[G0]]
 declare x86_fp80 @tanhl(x86_fp80)
 
-; CHECK: declare x86_fp80 @tanl(x86_fp80)
+; CHECK: declare x86_fp80 @tanl(x86_fp80) [[G0]]
 declare x86_fp80 @tanl(x86_fp80)
 
-; CHECK: declare i64 @times(%opaque* nocapture) [[G0]]
+; CHECK: declare i64 @times(%opaque* nocapture) [[G1]]
 declare i64 @times(%opaque*)
 
-; CHECK: declare noalias %opaque* @tmpfile() [[G0]]
+; CHECK: declare noalias %opaque* @tmpfile() [[G1]]
 declare %opaque* @tmpfile()
 
-; CHECK-LINUX: declare noalias %opaque* @tmpfile64() [[G0]]
+; CHECK-LINUX: declare noalias %opaque* @tmpfile64() [[G1]]
 declare %opaque* @tmpfile64()
 
-; CHECK: declare i32 @toascii(i32)
+; CHECK: declare i32 @toascii(i32) [[G0]]
 declare i32 @toascii(i32)
 
-; CHECK: declare double @trunc(double)
+; CHECK: declare double @trunc(double) [[G0]]
 declare double @trunc(double)
 
-; CHECK: declare float @truncf(float)
+; CHECK: declare float @truncf(float) [[G0]]
 declare float @truncf(float)
 
-; CHECK: declare x86_fp80 @truncl(x86_fp80)
+; CHECK: declare x86_fp80 @truncl(x86_fp80) [[G0]]
 declare x86_fp80 @truncl(x86_fp80)
 
-; CHECK: declare i32 @uname(%opaque* nocapture) [[G0]]
+; CHECK: declare i32 @uname(%opaque* nocapture) [[G1]]
 declare i32 @uname(%opaque*)
 
-; CHECK: declare i32 @ungetc(i32, %opaque* nocapture) [[G0]]
+; CHECK: declare i32 @ungetc(i32, %opaque* nocapture) [[G1]]
 declare i32 @ungetc(i32, %opaque*)
 
-; CHECK: declare i32 @unlink(i8* nocapture readonly) [[G0]]
+; CHECK: declare i32 @unlink(i8* nocapture readonly) [[G1]]
 declare i32 @unlink(i8*)
 
-; CHECK: declare i32 @unsetenv(i8* nocapture readonly) [[G0]]
+; CHECK: declare i32 @unsetenv(i8* nocapture readonly) [[G1]]
 declare i32 @unsetenv(i8*)
 
-; CHECK: declare i32 @utime(i8* nocapture readonly, %opaque* nocapture readonly) [[G0]]
+; CHECK: declare i32 @utime(i8* nocapture readonly, %opaque* nocapture readonly) [[G1]]
 declare i32 @utime(i8*, %opaque*)
 
-; CHECK: declare i32 @utimes(i8* nocapture readonly, %opaque* nocapture readonly) [[G0]]
+; CHECK: declare i32 @utimes(i8* nocapture readonly, %opaque* nocapture readonly) [[G1]]
 declare i32 @utimes(i8*, %opaque*)
 
-; CHECK: declare noalias i8* @valloc(i64) [[G0]]
+; CHECK: declare noalias i8* @valloc(i64) [[G1]]
 declare i8* @valloc(i64)
 
-; CHECK: declare i32 @vfprintf(%opaque* nocapture, i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vfprintf(%opaque* nocapture, i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vfprintf(%opaque*, i8*, %opaque*)
 
-; CHECK: declare i32 @vfscanf(%opaque* nocapture, i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vfscanf(%opaque* nocapture, i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vfscanf(%opaque*, i8*, %opaque*)
 
-; CHECK: declare i32 @vprintf(i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vprintf(i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vprintf(i8*, %opaque*)
 
-; CHECK: declare i32 @vscanf(i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vscanf(i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vscanf(i8*, %opaque*)
 
-; CHECK: declare i32 @vsnprintf(i8* nocapture, i64, i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vsnprintf(i8* nocapture, i64, i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vsnprintf(i8*, i64, i8*, %opaque*)
 
-; CHECK: declare i32 @vsprintf(i8* nocapture, i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vsprintf(i8* nocapture, i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vsprintf(i8*, i8*, %opaque*)
 
-; CHECK: declare i32 @vsscanf(i8* nocapture readonly, i8* nocapture readonly, %opaque*) [[G0]]
+; CHECK: declare i32 @vsscanf(i8* nocapture readonly, i8* nocapture readonly, %opaque*) [[G1]]
 declare i32 @vsscanf(i8*, i8*, %opaque*)
 
-; CHECK: declare i64 @write(i32, i8* nocapture readonly, i64)
+; CHECK: declare i64 @write(i32, i8* nocapture readonly, i64) [[G0]]
 declare i64 @write(i32, i8*, i64)
 
 
 ; memset_pattern16 isn't available everywhere.
-; CHECK-DARWIN: declare void @memset_pattern16(i8* nocapture, i8* nocapture readonly, i64) [[G3:#[0-9]+]]
+; CHECK-DARWIN: declare void @memset_pattern16(i8* nocapture, i8* nocapture readonly, i64) [[G5:#[0-9]+]]
 declare void @memset_pattern16(i8*, i8*, i64)
 
-
-; CHECK: attributes [[G0]] = { nounwind }
-; CHECK: attributes [[G1]] = { nounwind readonly }
-; CHECK: attributes [[G2]] = { argmemonly nounwind readonly }
-; CHECK-DARWIN: attributes [[G3]] = { argmemonly }
+; CHECK: attributes [[G0]] = { nofree }
+; CHECK: attributes [[G1]] = { nofree nounwind }
+; CHECK: attributes [[G2]] = { nofree nounwind readonly }
+; CHECK: attributes [[G3]] = { nounwind }
+; CHECK: attributes [[G4]] = { argmemonly nofree nounwind readonly }
+; CHECK-DARWIN: attributes [[G5]] = { argmemonly nofree }

llvm/trunk/test/Transforms/InferFunctionAttrs/norecurse_debug.ll

 !17 = !{!""}
 !18 = !DILocation(line: 3, column: 14, scope: !2)
 !19 = !DILocation(line: 7, column: 6, scope: !2)
 !24 = !DILocation(line: 7, column: 14, scope: !2)
 !27 = !DILocation(line: 9, column: 20, scope: !2)
 !28 = !DILocation(line: 9, column: 18, scope: !2)
 !29 = !DILocation(line: 10, column: 1, scope: !2)
 
-; CHECK: attributes #0 = { norecurse nounwind }
+; CHECK: attributes #0 = { nofree norecurse nounwind }
 ; CHECK-NOT foo.coefficient1

llvm/trunk/test/Transforms/LICM/strlen.ll

 ; RUN: opt -S -inferattrs -basicaa -licm < %s | FileCheck %s
 
 define void @test(i64* noalias %loc, i8* noalias %a) {
 ; CHECK-LABEL: @test
 ; CHECK: @strlen
 ; CHECK-LABEL: loop:
   br label %loop
 
 loop:
   %res = call i64 @strlen(i8* %a)
   store i64 %res, i64* %loc
   br label %loop
 }
 
 ; CHECK: declare i64 @strlen(i8* nocapture) #0
-; CHECK: attributes #0 = { argmemonly nounwind readonly }
+; CHECK: attributes #0 = { argmemonly nofree nounwind readonly }
 declare i64 @strlen(i8*)
 
 

llvm/trunk/test/Transforms/LoopIdiom/basic.ll

loop.exit:
   br label %exit
 
 exit:
   ret void
 }
 
 ; Validate that "memset_pattern" has the proper attributes.
 ; CHECK: declare void @memset_pattern16(i8* nocapture, i8* nocapture readonly, i64) [[ATTRS:#[0-9]+]]
-; CHECK: [[ATTRS]] = { argmemonly }
+; CHECK: [[ATTRS]] = { argmemonly nofree }