[PATCH 25/27] [noalias] Clang CodeGen for restrict-qualified pointers

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Introduce support for restrict-qualified pointers as local variables,
as member of a struct, arrays of restrict-qualified pointers,
pointers to restrict qualified pointers.

The full support is enabled with '-ffull-restrict'.
Combine it with '-fno-noalias-arguments' to avoid putting the 'noalias'
attribute on restrict pointers used as argument. This combination is
needed to correctly support restrict arguments. It is kept as a separate option,
as in some cases, the stronger noalias attribute semantics result in better code.
(which also means that some analysis passes could still be made smarter).

Note: this is a stable point and tests should run fine with the patches applied up to this point.
Note: D68519 has been incorporated.

[jeroen.dobbelaere]

Adapt CodeGen to std::vector<int64_t> indices (was std::vector<long long>).
Adapt tests to i64 p.objId (was i32).

[erichkeane]

clang/lib/AST/Type.cpp

116

Rather than this recursion, could you just unpack it from the CannonTy? So replace 107 with:

Type *CannonTy = getCanonicalType()->getBaseElementTypeUnsafe();

That way this is all unpacked and saves you a recursion.

[jeroen.dobbelaere]

clang/lib/AST/Type.cpp

116

Yes, that seems to work.

[jeroen.dobbelaere]

clang/include/clang/Driver/CC1Options.td

287 ↗

(On Diff #223606)

I plan to move the options into the 'f_group'. These will then become: -fonly-restrict-arguments, -ffull-restrict and -fno-noalias-arguments.
I'll also be adding a '-fno-full-restrict' option, so that we can easily fall back to the legacy behavior when the default is toggled.

[jeroen.dobbelaere]

Speedup 'isRestrictOrContainsRestrictMembers' as hinted by Erich.
Moved options to the 'f_Group' and reworked the logic.

[zahiraam]

clang/lib/CodeGen/CGDecl.cpp

1933

Use of Twine would probably be good here?

clang/lib/CodeGen/CodeGenFunction.cpp

727

Remove the #if /#endif pair.

[jeroen.dobbelaere]

Thanks !

[jeroen.dobbelaere]

Use 'Twine', remove #if/#endif.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

This update adds a c++ testcase for the problem reported by @alexey.zhikhar that was fixed in D68512#1909260

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

clang/include/clang/AST/Type.h

public:
 
 
   /// Returns true if it is a class and it might be dynamic.
   bool mayBeDynamicClass() const;
 
   /// Returns true if it is not a class or if the class might not be dynamic.
   bool mayBeNotDynamicClass() const;
 
+  /// Returns true if this is a restrict pointer or contains a restrict pointer.
+  /// NOTE: A pointer to a restrict pointer does not count.
+  bool isRestrictOrContainsRestrictMembers() const;
+
+  /// Get the encoded indices, describing where in memory restrict pointers are
+  /// located.
+  std::vector<int64_t> getRestrictIndices() const;
+
+private:
+  void getRestrictIndices(std::vector<int64_t> &OutEncodedIndices,
+                          SmallVector<int64_t, 10> &InCurrentIndices) const;
+
+public:
   // Don't promise in the API that anything besides 'const' can be
   // easily added.
 
   /// Add the `const` type qualifier to this QualType.
   void addConst() {
     addFastQualifiers(Qualifiers::Const);
   }
   QualType withConst() const {

clang/include/clang/Basic/CodeGenOptions.def

CODEGENOPT(DumpCoverageMapping , 1, 0) ///< Dump the generated coverage mapping
 
   /// If -fpcc-struct-return or -freg-struct-return is specified.
 ENUM_CODEGENOPT(StructReturnConvention, StructReturnConventionKind, 2, SRCK_Default)
 
 CODEGENOPT(RelaxAll          , 1, 0) ///< Relax all machine code instructions.
 CODEGENOPT(RelaxedAliasing   , 1, 0) ///< Set when -fno-strict-aliasing is enabled.
 CODEGENOPT(StructPathTBAA    , 1, 0) ///< Whether or not to use struct-path TBAA.
 CODEGENOPT(NewStructPathTBAA , 1, 0) ///< Whether or not to use enhanced struct-path TBAA.
+CODEGENOPT(FullRestrict      , 1, 0) ///< Set when -ffull-restrict is enabled.
+CODEGENOPT(NoNoAliasArgAttr  , 1, 0) ///< Set when -fno-noalias-arguments is specified.
 CODEGENOPT(SaveTempLabels    , 1, 0) ///< Save temporary labels.
 CODEGENOPT(SanitizeAddressUseAfterScope , 1, 0) ///< Enable use-after-scope detection
                                                 ///< in AddressSanitizer
 CODEGENOPT(SanitizeAddressPoisonCustomArrayCookie, 1,
            0) ///< Enable poisoning operator new[] which is not a replaceable
               ///< global allocation function in AddressSanitizer
 CODEGENOPT(SanitizeAddressGlobalsDeadStripping, 1, 0) ///< Enable linker dead stripping
                                                       ///< of globals in AddressSanitizer

clang/include/clang/Driver/Options.td

 defm fixed_point : BoolFOption<"fixed-point",
   LangOpts<"FixedPoint">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Enable">, NegFlag<SetFalse, [], "Disable">,
   BothFlags<[], " fixed point types">>, ShouldParseIf<!strconcat("!", cplusplus.KeyPath)>;
 defm cxx_static_destructors : BoolFOption<"c++-static-destructors",
   LangOpts<"RegisterStaticDestructors">, DefaultTrue,
   NegFlag<SetFalse, [CC1Option], "Disable C++ static destructor registration">,
   PosFlag<SetTrue>>;
+defm full_restrict : BoolFOption<"full-restrict",
+  CodeGenOpts<"FullRestrict">, DefaultFalse,
+  PosFlag<SetTrue, [], "Enable full restrict support">,
+  NegFlag<SetFalse, [], "Disable full restrict support">,
+  BothFlags<[CoreOption, CC1Option]>>;
+
+// Keep this behind an option - the alias analysis still works better
+// with the noalias attribute on arguments.
+defm fnoalias_arguments : BoolFOption<"noalias-arguments",
+  CodeGenOpts<"NoNoAliasArgAttr">, DefaultFalse,
+  NegFlag<SetTrue, [CC1Option], "Do not map restrict arguments onto the noalias attribute">,
+  PosFlag<SetFalse, [], "Also map restrict arguments onto the noalias attribute (default)">,
+  BothFlags<[CoreOption]>>;
 def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>,
   Flags<[CC1Option]>, MarshallingInfoString<CodeGenOpts<"SymbolPartition">>;
 
 defm memory_profile : OptInFFlag<"memory-profile", "Enable", "Disable", " heap memory profiling">;
 def fmemory_profile_EQ : Joined<["-"], "fmemory-profile=">,
     Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<directory>">,
     HelpText<"Enable heap memory profiling and dump results into <directory>">;
 

clang/lib/AST/Type.cpp

bool QualType::mayBeDynamicClass() const {
   return ClassDecl && ClassDecl->mayBeDynamicClass();
 }
 
 bool QualType::mayBeNotDynamicClass() const {
   const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
   return !ClassDecl || ClassDecl->mayBeNonDynamicClass();
 }
 
+bool QualType::isRestrictOrContainsRestrictMembers() const {
+  if (isRestrictQualified()) {
+    return true;
+  }
+
+  const Type *BaseElementType = getCanonicalType()->getBaseElementTypeUnsafe();
+  assert(!isa<ArrayType>(BaseElementType));
+
+  if (const RecordType *RecTy = dyn_cast<RecordType>(BaseElementType)) {
+    RecordDecl *RD = RecTy->getDecl();
+    for (FieldDecl *FD : RD->fields()) {
+      if (FD->getType().isRestrictOrContainsRestrictMembers()) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+std::vector<int64_t> QualType::getRestrictIndices() const {
+  // -1 represents an unbounded array
+  std::vector<int64_t> EncodedIndices;
+  SmallVector<int64_t, 10> BaseIndices = {-1};
+
+  getRestrictIndices(EncodedIndices, BaseIndices);
+
+  return EncodedIndices;
+}
+
+void QualType::getRestrictIndices(
+    std::vector<int64_t> &OutEncodedIndices,
+    SmallVector<int64_t, 10> &InCurrentIndices) const {
+  if (isRestrictQualified()) {
+    OutEncodedIndices.push_back(InCurrentIndices.size());
+    OutEncodedIndices.insert(OutEncodedIndices.end(), InCurrentIndices.begin(),
+                             InCurrentIndices.end());
+
+    return;
+  }
+
+  QualType CannonTy = getCanonicalType();
+  if (const auto *RecTy = CannonTy->getAs<RecordType>()) {
+    RecordDecl *RD = RecTy->getDecl();
+    InCurrentIndices.push_back(0);
+    for (FieldDecl *FD : RD->fields()) {
+      FD->getType().getRestrictIndices(OutEncodedIndices, InCurrentIndices);
+      InCurrentIndices.back()++;
+    }
+    InCurrentIndices.pop_back();
+  } else if (const auto *ArrayTy = dyn_cast<ArrayType>(CannonTy)) {
+    // Note: we use -1 for bounded and unbounded arrays
+    InCurrentIndices.push_back(-1); // -1 indicates that any index is fine
+    ArrayTy->getElementType().getRestrictIndices(OutEncodedIndices,
+                                                 InCurrentIndices);
+    InCurrentIndices.pop_back();
+  }
+}
+
 bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
   if (T.isConstQualified())
     return true;
 
   if (const ArrayType *AT = Ctx.getAsArrayType(T))
     return AT->getElementType().isConstant(Ctx);
 
   return T.getAddressSpace() == LangAS::opencl_constant;

clang/lib/CodeGen/Address.h

public:
   static Address invalid() { return Address(nullptr, CharUnits()); }
   bool isValid() const { return Pointer != nullptr; }
 
   llvm::Value *getPointer() const {
     assert(isValid());
     return Pointer;
   }
 
+  /// Replace the current pointer of the addres with a new pointer.
+  void adaptPointer(llvm::Value *newPointer) {
+    assert(Pointer->getType() == newPointer->getType() &&
+           "Address: changing the pointer must not change the type");
+    Pointer = newPointer;
+  }
+
   /// Return the type of the pointer value.
   llvm::PointerType *getType() const {
     return llvm::cast<llvm::PointerType>(getPointer()->getType());
   }
 
   /// Return the type of the values stored in this address.
   ///
   /// When IR pointer types lose their element type, we should simply

clang/lib/CodeGen/CGCall.cpp

case ABIArgInfo::Direct: {
               AI->removeAttr(llvm::Attribute::AttrKind::Alignment);
               AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(
                   llvm::Align(AlignmentInt)));
             }
           }
         }
 
         // Set 'noalias' if an argument type has the `restrict` qualifier.
-        if (Arg->getType().isRestrictQualified())
+        // For accurate full restrict support, we should not annotate arguments
+        // with noalias. The noalias atttribute is too strong.
+        if (Arg->getType().isRestrictQualified() &&
+            (!CGM.getCodeGenOpts().NoNoAliasArgAttr))
           AI->addAttr(llvm::Attribute::NoAlias);
       }
 
       // Prepare the argument value. If we have the trivial case, handle it
       // with no muss and fuss.
       if (!isa<llvm::StructType>(ArgI.getCoerceToType()) &&
           ArgI.getCoerceToType() == ConvertType(Ty) &&
           ArgI.getDirectOffset() == 0) {
for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
 
     case ABIArgInfo::Extend:
     case ABIArgInfo::Direct: {
       if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
           ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
           ArgInfo.getDirectOffset() == 0) {
         assert(NumIRArgs == 1);
         llvm::Value *V;
-        if (!I->isAggregate())
+        if (!I->isAggregate()) {
           V = I->getKnownRValue().getScalarVal();
-        else
-          V = Builder.CreateLoad(
-              I->hasLValue() ? I->getKnownLValue().getAddress(*this)
-                             : I->getKnownRValue().getAggregateAddress());
+        } else {
+          Address Addr = I->hasLValue()
+                             ? I->getKnownLValue().getAddress(*this)
+                             : I->getKnownRValue().getAggregateAddress();
+          if (I->getType().isRestrictOrContainsRestrictMembers() &&
+              CGM.getCodeGenOpts().FullRestrict) {
+            // protect a load of an aggregate with restrict member pointers with
+            // an llvm.noalias.copy.guard.
+            // NOTE: also see CodeGenFunction::EmitAggregateCopy();
+            auto NoAliasScopeMD =
+                getExistingOrUnknownNoAliasScope(Addr.getPointer());
+            auto NoAliasDecl = getExistingNoAliasDeclOrNullptr(NoAliasScopeMD);
+            Addr.adaptPointer(Builder.CreateNoAliasCopyGuard(
+                Addr.getPointer(), NoAliasDecl,
+                I->getType().getRestrictIndices(), NoAliasScopeMD));
+          }
+          llvm::LoadInst *LD =
+              Builder.CreateLoad(Addr, I->getType().isVolatileQualified());
+          V = LD;
+        }
 
         // Implement swifterror by copying into a new swifterror argument.
         // We'll write back in the normal path out of the call.
         if (CallInfo.getExtParameterInfo(ArgNo).getABI()
               == ParameterABI::SwiftErrorResult) {
           assert(!swiftErrorTemp.isValid() && "multiple swifterror args");
 
           QualType pointeeTy = I->Ty->getPointeeType();
case ABIArgInfo::Direct: {
         for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
           Address EltPtr = Builder.CreateStructGEP(Src, i);
           llvm::Value *LI = Builder.CreateLoad(EltPtr);
           IRCallArgs[FirstIRArg + i] = LI;
         }
       } else {
         // In the simple case, just pass the coerced loaded value.
         assert(NumIRArgs == 1);
+        if (Src.getElementType() == ArgInfo.getCoerceToType()) {
+          QualType Ty = I->getType();
+          if (Ty.isRestrictOrContainsRestrictMembers() &&
+              CGM.getCodeGenOpts().FullRestrict) {
+            // Protect a load of an aggregate with restrict member pointers with
+            // an llvm.noalias.copy.guard
+            // NOTE: also see CodeGenFunction::EmitAggregateCopy();
+            auto NoAliasScopeMD =
+                getExistingOrUnknownNoAliasScope(Src.getPointer());
+            auto NoAliasDecl = getExistingNoAliasDeclOrNullptr(NoAliasScopeMD);
+            Src.adaptPointer(Builder.CreateNoAliasCopyGuard(
+                Src.getPointer(), NoAliasDecl, Ty.getRestrictIndices(),
+                NoAliasScopeMD));
+          }
+        }
+
         llvm::Value *Load =
             CreateCoercedLoad(Src, ArgInfo.getCoerceToType(), *this);
 
         if (CallInfo.isCmseNSCall()) {
           // For certain parameter types, clear padding bits, as they may reveal
           // sensitive information.
           // Small struct/union types are passed as integer arrays.
           auto *ATy = dyn_cast<llvm::ArrayType>(Load->getType());

clang/lib/CodeGen/CGDecl.cpp

 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Type.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 static_assert(clang::Sema::MaximumAlignment <= llvm::Value::MaximumAlignment,
               "Clang max alignment greater than what LLVM supports?");
 
static llvm::Constant *replaceUndef(CodeGenModule &CGM, IsPattern isPattern,
   return llvm::ConstantVector::get(Values);
 }
 
 /// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
 /// variable declaration with auto, register, or no storage class specifier.
 /// These turn into simple stack objects, or GlobalValues depending on target.
 void CodeGenFunction::EmitAutoVarDecl(const VarDecl &D) {
   AutoVarEmission emission = EmitAutoVarAlloca(D);
+  EmitAutoVarNoAlias(emission);
   EmitAutoVarInit(emission);
   EmitAutoVarCleanups(emission);
 }
 
 /// Emit a lifetime.begin marker if some criteria are satisfied.
 /// \return a pointer to the temporary size Value if a marker was emitted, null
 /// otherwise
 llvm::Value *CodeGenFunction::EmitLifetimeStart(uint64_t Size,
void CodeGenFunction::EmitAutoVarInit(const AutoVarEmission &emission) {
   }
 
   llvm::Type *BP = CGM.Int8Ty->getPointerTo(Loc.getAddressSpace());
   emitStoresForConstant(
       CGM, D, (Loc.getType() == BP) ? Loc : Builder.CreateBitCast(Loc, BP),
       type.isVolatileQualified(), Builder, constant, /*IsAutoInit=*/false);
 }
 
+// For all local restrict-qualified local variables, we create a noalias
+// metadata scope. This scope is used to identify each restrict-qualified
+// variable and the other memory accesses within the scope where its aliasing
+// assumptions apply. The scope metadata is stored in the NoAliasAddrMap map
+// where the pointer to the local variable is the key in the map.
+// One variable can contain multiple restrict pointers. All of them are
+// represented by a single scope.
+void CodeGenFunction::EmitNoAliasDecl(const VarDecl &D, Address Loc) {
+  // Don't emit noalias intrinsics unless we're optimizing.
+  if (CGM.getCodeGenOpts().OptimizationLevel == 0)
+    return;
+
+  if (!CGM.getCodeGenOpts().FullRestrict)
+    return;
+
+  QualType type = D.getType();
+
+  // Emit a noalias intrinsic for restrict-qualified variables.
+  if (!type.isRestrictOrContainsRestrictMembers())
+    return;
+
+  // Only emit a llvm.noalias.decl if the address is an alloca.
+  if (!isa<llvm::AllocaInst>(Loc.getPointer()->stripPointerCasts()))
+    return;
+
+  // NOTE: keep in sync with (clang) CGDecl: getExistingOrUnknownNoAliasScope
+  // NOTE: keep in sync with (clang) CGDecl: EmitAutoVarNoAlias/EmitNoAliasDecl
+  // NOTE: keep in sync with (llvm) InlineFunction: CloneAliasScopeMetadata
+  llvm::MDBuilder MDB(CurFn->getContext());
+  if (!NoAliasDomain)
+    NoAliasDomain = MDB.createAnonymousAliasScopeDomain(CurFn->getName());
+
+  std::string Name = (llvm::Twine(CurFn->getName()) + ": " + D.getName()).str();
+
+  llvm::MDNode *Scope = MDB.createAnonymousAliasScope(NoAliasDomain, Name);
+  addNoAliasScope(Scope);
+
+  SmallVector<llvm::Metadata *, 8> ScopeListEntries(1, Scope);
+  llvm::MDNode *ScopeList =
+      llvm::MDNode::get(CurFn->getContext(), ScopeListEntries);
+
+  NoAliasAddrMap[Loc.getPointer()] = ScopeList;
+
+  if (HaveInsertPoint()) {
+    NoAliasDeclMap[ScopeList] =
+        Builder.CreateNoAliasDeclaration(Loc.getPointer(), ScopeList);
+  }
+}
+
+llvm::MDNode *
+CodeGenFunction::getExistingOrUnknownNoAliasScope(llvm::Value *Ptr) {
+  auto NAI = NoAliasAddrMap.find(
+      Ptr->stripInBoundsOffsets()); // make sure to find the base object
+
+  if (NAI != NoAliasAddrMap.end()) {
+    return NAI->second;
+  }
+  if (!NoAliasUnknownScope) {
+    // NOTE: keep in sync with (clang) CGDecl:getExistingOrUnknownNoAliasScope
+    // NOTE: keep in sync with (clang) CGDecl:EmitAutoVarNoAlias/EmitNoAliasDecl
+    // NOTE: keep in sync with (llvm) InlineFunction:CloneAliasScopeMetadata
+
+    // The unknown scope is used when we cannot yet pinpoint the exact scope.
+    llvm::MDBuilder MDB(CurFn->getContext());
+    if (!NoAliasDomain)
+      NoAliasDomain = MDB.createAnonymousAliasScopeDomain(CurFn->getName());
+    std::string Name =
+        (llvm::Twine(CurFn->getName()) + ": unknown scope").str();
+
+    llvm::MDNode *Scope = MDB.createAnonymousAliasScope(NoAliasDomain, Name);
+    FnNoAliasInfo.addNoAliasScope(Scope); // keep this at function level
+
+    SmallVector<llvm::Metadata *, 8> ScopeListEntries(1, Scope);
+    NoAliasUnknownScope =
+        llvm::MDNode::get(CurFn->getContext(), ScopeListEntries);
+    CurFn->setMetadata("noalias", NoAliasUnknownScope);
+  }
+
+  return NoAliasUnknownScope;
+}
+
+llvm::Value *
+CodeGenFunction::getExistingNoAliasDeclOrNullptr(llvm::MDNode *NoAliasScopeMD) {
+  llvm::Value *&NoAliasDecl = NoAliasDeclMap[NoAliasScopeMD];
+  if (NoAliasDecl == nullptr) {
+    NoAliasDecl = llvm::ConstantPointerNull::get(
+        llvm::Type::getInt8PtrTy(getLLVMContext()));
+  }
+  return NoAliasDecl;
+}
+
+void CodeGenFunction::EmitAutoVarNoAlias(const AutoVarEmission &emission) {
+  assert(emission.Variable && "emission was not valid!");
+
+  // Don't emit noalias intrinsics unless we're optimizing.
+  if (CGM.getCodeGenOpts().OptimizationLevel == 0)
+    return;
+
+  if (!CGM.getCodeGenOpts().FullRestrict)
+    return;
+
+  const VarDecl &D = *emission.Variable;
+
+  // Early exit: emission.getObjectAddress(..) can introduce extra code.
+  // Only do it if it is needed
+  if (!D.getType().isRestrictOrContainsRestrictMembers())
+    return;
+
+  // Check whether this is a byref variable that's potentially
+  // captured and moved by its own initializer.  If so, we'll need to
+  // emit the initializer first, then copy into the variable.
+  const Expr *Init = D.getInit();
+  bool capturedByInit =
+      Init && emission.IsEscapingByRef && isCapturedBy(D, Init);
+
+  Address Loc =
+      capturedByInit ? emission.Addr : emission.getObjectAddress(*this);
+  EmitNoAliasDecl(D, Loc);
+}
+
 /// Emit an expression as an initializer for an object (variable, field, etc.)
 /// at the given location.  The expression is not necessarily the normal
 /// initializer for the object, and the address is not necessarily
 /// its normal location.
 ///
 /// \param init the initializing expression
 /// \param D the object to act as if we're initializing
 /// \param lvalue the lvalue to initialize
if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
                               D.getName() + ".addr");
     }
     DoStore = true;
   }
 
   llvm::Value *ArgVal = (DoStore ? Arg.getDirectValue() : nullptr);
 
   LValue lv = MakeAddrLValue(DeclPtr, Ty);
+
+  EmitNoAliasDecl(D, DeclPtr);
+
   if (IsScalar) {
     Qualifiers qs = Ty.getQualifiers();
     if (Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
       // We honor __attribute__((ns_consumed)) for types with lifetime.
       // For __strong, it's handled by just skipping the initial retain;
       // otherwise we have to balance out the initial +1 with an extra
       // cleanup to do the release at the end of the function.
       bool isConsumed = D.hasAttr<NSConsumedAttr>();

clang/lib/CodeGen/CGExpr.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/NSAPI.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
 
 #include <string>
 
llvm::Value *CodeGenFunction::EmitLoadOfScalar(Address Addr, bool Volatile,
 
   if (EmitScalarRangeCheck(Load, Ty, Loc)) {
     // In order to prevent the optimizer from throwing away the check, don't
     // attach range metadata to the load.
   } else if (CGM.getCodeGenOpts().OptimizationLevel > 0)
     if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty))
       Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
 
+  // If this is a load from a restrict-qualified variable, then we have pointer
+  // aliasing assumptions that can be applied to the pointer value being loaded.
+  if (Ty.isRestrictQualified() && CGM.getCodeGenOpts().FullRestrict) {
+    auto NoAliasScopeMD = getExistingOrUnknownNoAliasScope(Addr.getPointer());
+    auto NoAliasDecl = getExistingNoAliasDeclOrNullptr(NoAliasScopeMD);
+    auto *NoAliasLoad = Builder.CreateNoAliasPointer(
+        Load, NoAliasDecl, Addr.getPointer(), NoAliasScopeMD);
+
+    // The llvm.noalias intrinsic can make use of the available alias info
+    llvm::AAMDNodes AAMetadata;
+    Load->getAAMetadata(AAMetadata);
+    NoAliasLoad->setAAMetadata(AAMetadata);
+
+    // ..as wel as the local restrict scope
+    // In both cases, this is about the 'P.addr'(getOperand(2) of llvm.noalias)
+    recordMemoryInstruction(NoAliasLoad);
+    return EmitFromMemory(NoAliasLoad, Ty);
+  }
   return EmitFromMemory(Load, Ty);
 }
 
 llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
   // Bool has a different representation in memory than in registers.
   if (hasBooleanRepresentation(Ty)) {
     // This should really always be an i1, but sometimes it's already
     // an i8, and it's awkward to track those cases down.

clang/lib/CodeGen/CGExprAgg.cpp

if (const RecordType *RT = Ty->getAs<RecordType>()) {
              "Trying to aggregate-copy a type without a trivial copy/move "
              "constructor or assignment operator");
       // Ignore empty classes in C++.
       if (Record->isEmpty())
         return;
     }
   }
 
+  // Guard copies of structs containing restrict pointers
+  if (Ty.isRestrictOrContainsRestrictMembers() &&
+      CGM.getCodeGenOpts().FullRestrict) {
+    // NOTE: also see CodeGenFunction::EmitCall()
+    auto NoAliasScopeMD = getExistingOrUnknownNoAliasScope(SrcPtr.getPointer());
+    auto NoAliasDecl = getExistingNoAliasDeclOrNullptr(NoAliasScopeMD);
+    SrcPtr.adaptPointer(Builder.CreateNoAliasCopyGuard(
+        SrcPtr.getPointer(), NoAliasDecl, Ty.getRestrictIndices(),
+        NoAliasScopeMD));
+  }
+
   if (getLangOpts().CUDAIsDevice) {
     if (Ty->isCUDADeviceBuiltinSurfaceType()) {
       if (getTargetHooks().emitCUDADeviceBuiltinSurfaceDeviceCopy(*this, Dest,
                                                                   Src))
         return;
     } else if (Ty->isCUDADeviceBuiltinTextureType()) {
       if (getTargetHooks().emitCUDADeviceBuiltinTextureDeviceCopy(*this, Dest,
                                                                   Src))
if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
         CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
                                                       SizeVal);
         return;
       }
     }
   }
 
   auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
+  // track noalias scope for memcpy
+  recordMemoryInstruction(Inst);
 
   // Determine the metadata to describe the position of any padding in this
   // memcpy, as well as the TBAA tags for the members of the struct, in case
   // the optimizer wishes to expand it in to scalar memory operations.
   if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty))
     Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);
 
   if (CGM.getCodeGenOpts().NewStructPathTBAA) {
     TBAAAccessInfo TBAAInfo = CGM.mergeTBAAInfoForMemoryTransfer(
         Dest.getTBAAInfo(), Src.getTBAAInfo());
     CGM.DecorateInstructionWithTBAA(Inst, TBAAInfo);
   }
 }

clang/lib/CodeGen/CGStmt.cpp

case Stmt::CaseStmtClass:
     break;
   case Stmt::SEHLeaveStmtClass:
     EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S));
     break;
   }
   return true;
 }
 
+bool CodeGenFunction::hasLocalRestrictVars(const CompoundStmt &S,
+                                           FunctionArgList *Args) {
+  // We may have restrict-qualified variables, but if we're not optimizing, we
+  // don't do anything special with them.
+  if (CGM.getCodeGenOpts().OptimizationLevel == 0)
+    return false;
+
+  if (Args)
+    for (const auto *VD : *Args)
+      if (VD->getType().isRestrictOrContainsRestrictMembers())
+        return true;
+
+  for (const auto *C : S.body())
+    if (const auto *DS = dyn_cast<DeclStmt>(C))
+      for (const auto *I : DS->decls())
+        if (const auto *VD = dyn_cast<VarDecl>(I))
+          if (VD->getType().isRestrictOrContainsRestrictMembers())
+            return true;
+
+  return false;
+}
+
 /// EmitCompoundStmt - Emit a compound statement {..} node.  If GetLast is true,
 /// this captures the expression result of the last sub-statement and returns it
 /// (for use by the statement expression extension).
 Address CodeGenFunction::EmitCompoundStmt(const CompoundStmt &S, bool GetLast,
                                           AggValueSlot AggSlot) {
   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),S.getLBracLoc(),
                              "LLVM IR generation of compound statement ('{}')");
 
   // Keep track of the current cleanup stack depth, including debug scopes.
-  LexicalScope Scope(*this, S.getSourceRange());
+  LexicalScope Scope(*this, S.getSourceRange(), hasLocalRestrictVars(S));
 
   return EmitCompoundStmtWithoutScope(S, GetLast, AggSlot);
 }
 
 Address
 CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S,
                                               bool GetLast,
                                               AggValueSlot AggSlot) {
void CodeGenFunction::LexicalScope::rescopeLabels() {
   }
 
   // Reparent the labels if the new scope also has cleanups.
   if (innermostScope != EHScopeStack::stable_end() && ParentScope) {
     ParentScope->Labels.append(Labels.begin(), Labels.end());
   }
 }
 
+// For all of the instructions generated for this lexical scope that access
+// memory, add the noalias metadata associated with any block-local
+// restrict-qualified pointers from this scope.
+void CodeGenFunction::LexicalNoAliasInfo::addNoAliasMD() {
+  if (MemoryInsts.empty() || NoAliasScopes.empty())
+    return;
+
+  llvm::MDNode *NewScopeList = llvm::MDNode::get(
+      MemoryInsts[0]->getParent()->getContext(), NoAliasScopes);
+
+  for (auto &I : MemoryInsts)
+    I->setMetadata(
+        llvm::LLVMContext::MD_noalias,
+        llvm::MDNode::concatenate(I->getMetadata(llvm::LLVMContext::MD_noalias),
+                                  NewScopeList));
+
+  MemoryInsts.clear();
+}
 
 void CodeGenFunction::EmitLabelStmt(const LabelStmt &S) {
   EmitLabel(S.getDecl());
 
   // IsEHa - emit eha.scope.begin if it's a side entry of a scope
   if (getLangOpts().EHAsynch && S.isSideEntry())
     EmitSehCppScopeBegin();
 

clang/lib/CodeGen/CodeGenFunction.h

 #include "clang/Basic/CapturedStmt.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
 
 namespace llvm {
 class BasicBlock;
 class LLVMContext;
public:
   typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>(
       CodeGenFunction &, const OMPExecutableDirective &S, Address LB,
       Address UB)>
       CodeGenDispatchBoundsTy;
 
   /// CGBuilder insert helper. This function is called after an
   /// instruction is created using Builder.
   void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
-                    llvm::BasicBlock *BB,
-                    llvm::BasicBlock::iterator InsertPt) const;
+                    llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt);
 
   /// CurFuncDecl - Holds the Decl for the current outermost
   /// non-closure context.
   const Decl *CurFuncDecl;
   /// CurCodeDecl - This is the inner-most code context, which includes blocks.
   const Decl *CurCodeDecl;
   const CGFunctionInfo *CurFnInfo;
   QualType FnRetTy;
void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) {
       CGF.DidCallStackSave = OldDidCallStackSave;
       CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
                            ValuesToReload);
       PerformCleanup = false;
       CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
     }
   };
 
+  // Check if any local variable or argument contains a (direct) restrict
+  // pointer.
+  bool hasLocalRestrictVars(const CompoundStmt &S,
+                            FunctionArgList *Args = nullptr);
+
+  // Get the associated NoAliasScope for the Ptr (cast and geps will be
+  // stripped). If there is no associated scope returns the 'unknown function'
+  // scope. (which is created on demand)
+  llvm::MDNode *getExistingOrUnknownNoAliasScope(llvm::Value *Ptr);
+
+  // Get the associated declaration
+  llvm::Value *getExistingNoAliasDeclOrNullptr(llvm::MDNode *NoAliasScopeMD);
+
+  // The noalias scopes used to tag pointer values assigned to block-local
+  // restrict-qualified variables, and the memory-accessing instructions within
+  // this lexical scope to which the associated pointer-aliasing assumptions
+  // might apply. One of these will exist for each lexical scope.
+  struct LexicalNoAliasInfo {
+    bool RecordMemoryInsts;
+    llvm::TinyPtrVector<llvm::Instruction *> MemoryInsts;
+    llvm::TinyPtrVector<llvm::Metadata *> NoAliasScopes;
+
+    LexicalNoAliasInfo(bool RecordMemoryInsts = false)
+        : RecordMemoryInsts(RecordMemoryInsts) {}
+
+    void recordMemoryInsts() { RecordMemoryInsts = true; }
+
+    void recordMemoryInstruction(llvm::Instruction *I) {
+      if (RecordMemoryInsts)
+        MemoryInsts.push_back(I);
+    }
+
+    void addNoAliasScope(llvm::MDNode *Scope) {
+      assert(RecordMemoryInsts &&
+             "Adding noalias scope but not recording memory accesses!");
+      NoAliasScopes.push_back(Scope);
+    }
+
+    void addNoAliasMD();
+  };
+
+  LexicalNoAliasInfo FnNoAliasInfo;
+
   // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
   EHScopeStack::stable_iterator CurrentCleanupScopeDepth =
       EHScopeStack::stable_end();
 
-  class LexicalScope : public RunCleanupsScope {
+  class LexicalScope : public RunCleanupsScope, public LexicalNoAliasInfo {
     SourceRange Range;
     SmallVector<const LabelDecl*, 4> Labels;
     LexicalScope *ParentScope;
 
     LexicalScope(const LexicalScope &) = delete;
     void operator=(const LexicalScope &) = delete;
 
   public:
     /// Enter a new cleanup scope.
-    explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range)
-      : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) {
+    explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range,
+                          bool RecordMemoryInsts = false)
+        : RunCleanupsScope(CGF), LexicalNoAliasInfo(RecordMemoryInsts),
+          Range(Range), ParentScope(CGF.CurLexicalScope) {
       CGF.CurLexicalScope = this;
       if (CGDebugInfo *DI = CGF.getDebugInfo())
         DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
     }
 
     void addLabel(const LabelDecl *label) {
       assert(PerformCleanup && "adding label to dead scope?");
       Labels.push_back(label);
     }
 
+    // If we have block-local restrict-qualified pointers, we need to keep
+    // track of the memory-accessing instructions in the blocks where such
+    // pointers are declared (including lexical scopes that are children of
+    // those blocks) so that we can later add the appropriate metadata. Record
+    // this instruction and so the same in any parent scopes.
+    void recordMemoryInstruction(llvm::Instruction *I) {
+      LexicalNoAliasInfo::recordMemoryInstruction(I);
+      if (ParentScope)
+        ParentScope->recordMemoryInstruction(I);
+      else
+        CGF.FnNoAliasInfo.recordMemoryInstruction(I);
+    }
+
     /// Exit this cleanup scope, emitting any accumulated
     /// cleanups.
     ~LexicalScope() {
       if (CGDebugInfo *DI = CGF.getDebugInfo())
         DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
 
       // If we should perform a cleanup, force them now.  Note that
       // this ends the cleanup scope before rescoping any labels.
       if (PerformCleanup) {
         ApplyDebugLocation DL(CGF, Range.getEnd());
         ForceCleanup();
       }
     }
 
     /// Force the emission of cleanups now, instead of waiting
     /// until this object is destroyed.
     void ForceCleanup() {
+      addNoAliasMD();
+
       CGF.CurLexicalScope = ParentScope;
       RunCleanupsScope::ForceCleanup();
 
       if (!Labels.empty())
         rescopeLabels();
     }
 
     bool hasLabels() const {
       return !Labels.empty();
     }
 
     void rescopeLabels();
   };
 
   typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
 
+  // Record this instruction for the purpose of later adding noalias metadata,
+  // is applicible, in order to support block-local restrict-qualified
+  // pointers.
+  void recordMemoryInstruction(llvm::Instruction *I) {
+    if (CurLexicalScope)
+      CurLexicalScope->recordMemoryInstruction(I);
+    else
+      FnNoAliasInfo.recordMemoryInstruction(I);
+  }
+
+  void addNoAliasScope(llvm::MDNode *Scope) {
+    if (CurLexicalScope)
+      CurLexicalScope->addNoAliasScope(Scope);
+    else
+      FnNoAliasInfo.addNoAliasScope(Scope);
+  }
+
   /// The class used to assign some variables some temporarily addresses.
   class OMPMapVars {
     DeclMapTy SavedLocals;
     DeclMapTy SavedTempAddresses;
     OMPMapVars(const OMPMapVars &) = delete;
     void operator=(const OMPMapVars &) = delete;
 
   public:
private:
   /// the constructor, but could be overwritten to true if this is a coroutine.
   bool ShouldEmitLifetimeMarkers;
 
   /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
   /// the function metadata.
   void EmitOpenCLKernelMetadata(const FunctionDecl *FD,
                                 llvm::Function *Fn);
 
+  /// The noalias domain metadata for this function.
+  llvm::MDNode *NoAliasDomain = nullptr;
+
+  /// A map between the addresses of local restrict-qualified variables and
+  /// their noalias scope.
+  llvm::DenseMap<llvm::Value *, llvm::MDNode *> NoAliasAddrMap;
+
+  /// A map between the noalias scope and its declaration
+  llvm::DenseMap<llvm::MDNode *, llvm::Value *> NoAliasDeclMap;
+
+  /// The node representing 'out-of-function' scope
+  llvm::MDNode *NoAliasUnknownScope = nullptr;
+
 public:
   CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
   ~CodeGenFunction();
 
   CodeGenTypes &getTypes() const { return CGM.getTypes(); }
   ASTContext &getContext() const { return CGM.getContext(); }
   CGDebugInfo *getDebugInfo() {
     if (DisableDebugInfo)
public:
     }
   };
   AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
   void EmitAutoVarInit(const AutoVarEmission &emission);
   void EmitAutoVarCleanups(const AutoVarEmission &emission);
   void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
                               QualType::DestructionKind dtorKind);
 
+  void EmitNoAliasDecl(const VarDecl &D, Address Loc);
+  void EmitAutoVarNoAlias(const AutoVarEmission &emission);
+
   /// Emits the alloca and debug information for the size expressions for each
   /// dimension of an array. It registers the association of its (1-dimensional)
   /// QualTypes and size expression's debug node, so that CGDebugInfo can
   /// reference this node when creating the DISubrange object to describe the
   /// array types.
   void EmitAndRegisterVariableArrayDimensions(CGDebugInfo *DI,
                                               const VarDecl &D,
                                               bool EmitDebugInfo);

clang/lib/CodeGen/CodeGenFunction.cpp

void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
   if (const auto *FD = dyn_cast_or_null<FunctionDecl>(D))
     if (FD->usesSEHTry())
       CurSEHParent = FD;
   CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
   FnRetTy = RetTy;
   CurFn = Fn;
   CurFnInfo = &FnInfo;
   assert(CurFn->isDeclaration() && "Function already has body?");
+  NoAliasUnknownScope = nullptr; // make sure we start without a function scope
+
+  // Always track memory instructions. When a restrict usage is encountered,
+  // they will be annotated with the necessary scopes.
+  FnNoAliasInfo.recordMemoryInsts();
 
   // If this function is ignored for any of the enabled sanitizers,
   // disable the sanitizer for the function.
   do {
 #define SANITIZER(NAME, ID)                                                    \
   if (SanOpts.empty())                                                         \
     break;                                                                     \
   if (SanOpts.has(SanitizerKind::ID))                                          \
     if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc))                    \
       SanOpts.set(SanitizerKind::ID, false);
#undef SANITIZER
   // target-features/target-cpu?
   if (CurFuncDecl)
     if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>())
       LargestVectorWidth = VecWidth->getVectorWidth();
 }
 
 void CodeGenFunction::EmitFunctionBody(const Stmt *Body) {
   incrementProfileCounter(Body);
-  if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
+  if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body)) {
     EmitCompoundStmtWithoutScope(*S);
-  else
+
+    // Now that we're done with the block, add noalias metadata if we had any
+    // block-local restrict-qualified pointers.
+    FnNoAliasInfo.addNoAliasMD();
+  } else {
     EmitStmt(Body);
+  }
 
   // This is checked after emitting the function body so we know if there
   // are any permitted infinite loops.
   if (checkIfFunctionMustProgress())
     CurFn->addFnAttr(llvm::Attribute::MustProgress);
 }
 
 /// When instrumenting to collect profile data, the counts for some blocks

 
 CodeGenFunction::SanitizerScope::~SanitizerScope() {
   CGF->IsSanitizerScope = false;
 }
 
 void CodeGenFunction::InsertHelper(llvm::Instruction *I,
                                    const llvm::Twine &Name,
                                    llvm::BasicBlock *BB,
-                                   llvm::BasicBlock::iterator InsertPt) const {
+                                   llvm::BasicBlock::iterator InsertPt) {
   LoopStack.InsertHelper(I);
   if (IsSanitizerScope)
     CGM.getSanitizerMetadata()->disableSanitizerForInstruction(I);
+
+  // When we have block-local restrict-qualified pointers, we need to record
+  // all memory-accessing instructions (i.e. any kind of instruction for which
+  // AA::getModRefInfo might return something other than NoModRef) so that they
+  // can be tagged with noalias metadata with noalias scopes corresponding to
+  // the applicable restrict-qualified pointers.
+  if (I->mayReadOrWriteMemory())
+    recordMemoryInstruction(I);
 }
 
 void CGBuilderInserter::InsertHelper(
     llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
     llvm::BasicBlock::iterator InsertPt) const {
   llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
   if (CGF)
     CGF->InsertHelper(I, Name, BB, InsertPt);

clang/lib/Driver/ToolChains/Clang.cpp

#endif
   if (Args.hasFlag(options::OPT_fmerge_all_constants,
                    options::OPT_fno_merge_all_constants, false))
     CmdArgs.push_back("-fmerge-all-constants");
 
   if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks,
                    options::OPT_fdelete_null_pointer_checks, false))
     CmdArgs.push_back("-fno-delete-null-pointer-checks");
 
+  if (Arg *FullRestrictArg = Args.getLastArg(options::OPT_ffull_restrict,
+                                             options::OPT_fno_full_restrict)) {
+    if (FullRestrictArg->getOption().matches(options::OPT_ffull_restrict)) {
+      // Enable inlining support for noalias (currently disabled by default)
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-use-noalias-intrinsic-during-inlining");
+    }
+  }
+
   // LLVM Code Generator Options.
 
   for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file_EQ)) {
     StringRef Map = A->getValue();
     if (!llvm::sys::fs::exists(Map)) {
       D.Diag(diag::err_drv_no_such_file) << Map;
     } else {
       A->render(Args, CmdArgs);

clang/test/CodeGen/restrict/arg_reuse.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict -fno-noalias-arguments %s -emit-llvm -o - | FileCheck %s
+
+// NOTE: use -no-noalias-arguments to block mapping restrict arguments on the 'noalias
+//  attribute which is too strong for restrict
+
+// A number of testcases from our wiki (2018/6/7_llvm_restrict_examples
+// As llvm/clang treat __restrict differently in following cases:
+int test_arg_restrict_vs_local_restrict_01(int *__restrict pA, int *pB, int *pC) {
+  int *tmp = pA;
+  *tmp = 42;
+  pA = pB;
+  *pA = 43;
+  *pC = 99;
+  return *tmp; // fail: needs a load !!! (either 42 or 43)
+}
+
+// CHECK: @test_arg_restrict_vs_local_restrict_01
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 43
+// CHECK-NOT: ret i32 99
+
+int test_arg_restrict_vs_local_restrict_02(int *pA_, int *pB, int *pC) {
+  int *__restrict pA;
+  pA = pA_;
+  int *tmp = pA;
+  *tmp = 42;
+  pA = pB;
+  *pA = 43;
+  *pC = 99;
+  return *tmp; // needs a load !!! (either 42 or 43)
+}
+
+// CHECK: @test_arg_restrict_vs_local_restrict_02
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 43
+// CHECK-NOT: ret i32 99

clang/test/CodeGen/restrict/array.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-optzns -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+int r;
+void ex1(int *);
+
+void test_FOO_local(int *pA, int *pB, int *pC) {
+  int *restrict tmp[3] = {pA, pB, pC};
+  *tmp[0] = 42;
+  *tmp[1] = 43;
+}
+
+// CHECK-LABEL: void @test_FOO_local(
+// CHECK:  [[tmp:%.*]] = alloca [3 x i32*], align 16
+// CHECK:  [[TMP1:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0a3p0i32.i64([3 x i32*]* [[tmp]], i64 0, metadata [[TAG_6:!.*]])
+// CHECK:  [[arrayidx_begin:%.*]] = getelementptr inbounds [3 x i32*], [3 x i32*]* [[tmp]], i64 0, i64 0
+// CHECK:  [[arrayidx:%.*]] = getelementptr inbounds [3 x i32*], [3 x i32*]* [[tmp]], i64 0, i64 0
+// CHECK:  [[TMP5:%.*]] = load i32*, i32** [[arrayidx]], align 16, !tbaa [[TAG_2:!.*]], !noalias [[TAG_6]]
+// CHECK:  [[TMP6:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP5]], i8* [[TMP1]], i32** [[arrayidx]], i64 0, metadata [[TAG_6]]), !tbaa [[TAG_2]], !noalias [[TAG_6]]
+// CHECK:  store i32 42, i32* [[TMP6]], align 4, !tbaa [[TAG_9:!.*]], !noalias [[TAG_6]]
+// CHECK:  [[arrayidx2:%.*]] = getelementptr inbounds [3 x i32*], [3 x i32*]* [[tmp]], i64 0, i64 1
+// CHECK:  [[TMP7:%.*]] = load i32*, i32** [[arrayidx2]], align 8, !tbaa [[TAG_2]], !noalias [[TAG_6]]
+// CHECK:  [[TMP8:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP7]], i8* [[TMP1]], i32** [[arrayidx2]], i64 0, metadata [[TAG_6]]), !tbaa [[TAG_2]], !noalias [[TAG_6]]
+// CHECK:  store i32 43, i32* [[TMP8]], align 4, !tbaa [[TAG_9]], !noalias [[TAG_6]]
+// CHECK:  ret void
+
+void test_FOO_p(int *restrict p) {
+  *p = 42;
+}
+
+// define void @test_FOO_p(i32* noalias %p) #0 {
+// CHECK-LABEL: void @test_FOO_p(
+// CHECK:       [[p_addr:%.*]] = alloca i32*, align 8
+// CHECK-NEXT:  [[TMP0:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** [[p_addr]], i64 0, metadata [[TAG_11:!.*]])
+// CHECK-NEXT:  store i32* [[p:%.*]], i32** [[p_addr]], align 8, !tbaa [[TAG_2:!.*]], !noalias [[TAG_11]]
+// CHECK-NEXT:  [[TMP1:%.*]] = load i32*, i32** [[p_addr]], align 8, !tbaa [[TAG_2]], !noalias [[TAG_11]]
+// CHECK-NEXT:  [[TMP2:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP1]], i8* [[TMP0]], i32** [[p_addr]], i64 0, metadata [[TAG_11]]), !tbaa [[TAG_2]], !noalias [[TAG_11]]
+// CHECK-NEXT:  store i32 42, i32* [[TMP2]], align 4, !tbaa [[TAG_9:!.*]], !noalias [[TAG_11]]
+// CHECK-NEXT:  ret void
+
+void test_FOO_pp(int *restrict *p) {
+  *p[0] = 42;
+}
+
+// define void @test_FOO_pp(i32** %p) #0 !noalias !14 {
+// CHECK: void @test_FOO_pp(i32** [[p:%.*]]) #0 !noalias [[TAG_14:!.*]] {
+// CHECK:       [[p_addr:%.*]] = alloca i32**, align 8
+// CHECK-NEXT:  store i32** [[p]], i32*** [[p_addr]], align 8, !tbaa [[TAG_2:!.*]], !noalias [[TAG_14:!.*]]
+// CHECK-NEXT:  [[TMP0:%.*]] = load i32**, i32*** [[p_addr]], align 8, !tbaa [[TAG_2]], !noalias [[TAG_14]]
+// CHECK-NEXT:  [[arrayidx:%.*]] = getelementptr inbounds i32*, i32** [[TMP0]], i64 0
+// CHECK-NEXT:  [[TMP1:%.*]] = load i32*, i32** [[arrayidx]], align 8, !tbaa [[TAG_2]], !noalias [[TAG_14]]
+// CHECK-NEXT:  [[TMP2:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP1]], i8* null, i32** [[arrayidx]], i64 0, metadata [[TAG_14]]), !tbaa [[TAG_2]], !noalias [[TAG_14]]
+// CHECK-NEXT:  store i32 42, i32* [[TMP2]], align 4, !tbaa [[TAG_9:!.*]], !noalias [[TAG_14]]
+// CHECK-NEXT:  ret void

clang/test/CodeGen/restrict/basic.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-optzns -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+int r;
+void ex1(int *);
+
+int *a;
+int *foo() {
+  int *restrict x = a;
+  return x;
+
+  // CHECK-LABEL: i32* @foo(
+  // CHECK:  [[x:%.*]] = alloca i32*, align 8
+  // CHECK:  [[TMP1:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** [[x]], i64 0, metadata  [[TAG_2:!.*]])
+  // CHECK:  [[TMP3:%.*]] = load i32*, i32** [[x]], align 8, !tbaa !5, !noalias [[TAG_2]]
+  // CHECK:  [[TMP4:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP3]], i8* [[TMP1]], i32** [[x]], i64 0, metadata !2), !tbaa !5, !noalias [[TAG_2]]
+  // CHECK:  ret i32* [[TMP4]]
+}
+
+int *a2;
+int *foo1(int b) {
+  int *restrict x;
+
+  // CHECK-LABEL: define i32* @foo1(i32 %b)
+  // CHECK:  [[b_addr:%.*]] = alloca i32, align 4
+  // CHECK:  [[x:%.*]] = alloca i32*, align 8
+  // CHECK:  [[x2:%.*]] = alloca i32*, align 8
+  // CHECK:  [[TMP1:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** [[x]], i64 0, metadata [[TAG_x:!.*]])
+
+  if (b) {
+    x = a;
+    r += *x;
+    ex1(x);
+
+    // CHECK:  [[TMP3:%.*]] = load i32*, i32** @a, align 8, !tbaa [[TAG_5:!.*]], !noalias [[TAG_x_x2:!.*]]
+    // CHECK:  store i32* [[TMP3]], i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP4:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP5:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP4]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP6:%.*]] = load i32, i32* [[TMP5]], align 4, !tbaa [[TAG_9:!.*]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP7:%.*]] = load i32, i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[add:%.*]] = add nsw i32 [[TMP7]], [[TMP6]]
+    // CHECK:  store i32 [[add]], i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP8:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP9:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP8]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  call void @ex1(i32* [[TMP9]]), !noalias [[TAG_x_x2]]
+
+    ++x;
+    *x = r;
+    ex1(x);
+
+    // CHECK:  [[TMP10:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP11:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP10]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[incdec_ptr:%.*]] = getelementptr inbounds i32, i32* [[TMP11]], i32 1
+    // CHECK:  store i32* [[incdec_ptr]], i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP12:%.*]] = load i32, i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP13:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP14:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP13]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  store i32 [[TMP12]], i32* [[TMP14]], align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP15:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP16:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP15]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  call void @ex1(i32* [[TMP16]]), !noalias [[TAG_x_x2]]
+
+    x += b;
+    *x = r;
+    ex1(x);
+
+    // CHECK:  [[TMP17:%.*]] = load i32, i32* [[b_addr]], align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP18:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP19:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP18]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[idx_ext:%.*]] = sext i32 [[TMP17]] to i64
+    // CHECK:  [[add_ptr:%.*]] = getelementptr inbounds i32, i32* [[TMP19]], i64 [[idx_ext]]
+    // CHECK:  store i32* [[add_ptr]], i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP20:%.*]] = load i32, i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP21:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP22:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP21]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  store i32 [[TMP20]], i32* [[TMP22]], align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP23:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP24:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP23]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  call void @ex1(i32* [[TMP24]]), !noalias [[TAG_x_x2]]
+
+    int *restrict x2 = a2;
+    *x2 = r;
+    ex1(x2);
+
+    // CHECK:  [[TMP26:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** [[x2]], i64 0, metadata [[TAG_x2:!.*]])
+    // CHECK:  [[TMP27:%.*]] = load i32*, i32** @a2, align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  store i32* [[TMP27]], i32** [[x2]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP28:%.*]] = load i32, i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP29:%.*]] = load i32*, i32** [[x2]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP30:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP29]], i8* [[TMP26]], i32** [[x2]], i64 0, metadata [[TAG_x2]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  store i32 [[TMP28]], i32* [[TMP30]], align 4, !tbaa [[TAG_9]], !noalias [[TAG_x_x2]]
+
+    // CHECK:  [[TMP31:%.*]] = load i32*, i32** [[x2]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  [[TMP32:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP31]], i8* [[TMP26]], i32** [[x2]], i64 0, metadata [[TAG_x2]]), !tbaa [[TAG_5]], !noalias [[TAG_x_x2]]
+    // CHECK:  call void @ex1(i32* [[TMP32]]), !noalias [[TAG_x_x2]]
+  } else {
+    x = a2;
+    r += *x;
+    // CHECK:  [[TMP34:%.*]] = load i32*, i32** @a2, align 8, !tbaa [[TAG_5]], !noalias [[TAG_x]]
+    // CHECK:  store i32* [[TMP34]], i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x]]
+
+    // CHECK:  [[TMP35:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x]]
+    // CHECK:  [[TMP36:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP35]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x]]
+    // CHECK:  [[TMP37:%.*]] = load i32, i32* [[TMP36]], align 4, !tbaa [[TAG_9]], !noalias [[TAG_x]]
+    // CHECK:  [[TMP38:%.*]] = load i32, i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x]]
+    // CHECK:  [[add1:%.*]] = add nsw i32 [[TMP38]], [[TMP37]]
+    // CHECK:  store i32 [[add1]], i32* @r, align 4, !tbaa [[TAG_9]], !noalias [[TAG_x]]
+  }
+
+  return x;
+  // CHECK:  [[TMP39:%.*]] = load i32*, i32** [[x]], align 8, !tbaa [[TAG_5]], !noalias [[TAG_x]]
+  // CHECK:  [[TMP40:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP39]], i8* [[TMP1]], i32** [[x]], i64 0, metadata [[TAG_x]]), !tbaa [[TAG_5]], !noalias [[TAG_x]]
+  // CHECK:  ret i32* [[TMP40]]
+}
+
+int *bar() {
+  int *x = a;
+  return x;
+
+  // CHECK-LABEL: define i32* @bar()
+  // CHECK-NOT: noalias
+  // CHECK: ret i32*
+}

clang/test/CodeGen/restrict/basic_opt_01.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// Rough test to verify basic functionality of the 'restrict member pointer' rewrite
+
+// CHECK: @test01A
+// CHECK: ret i32 42
+int test01A(int *pA, int *pB) {
+  int *__restrict prA;
+  prA = pA;
+
+  *prA = 42;
+  *pB = 43;
+  return *prA;
+}
+
+// CHECK: @test01B
+// CHECK: ret i32 42
+int test01B(int *__restrict prA, int *pB) {
+  *prA = 42;
+  *pB = 43;
+  return *prA;
+}
+
+// CHECK: @test02A
+// CHECK: ret i32 42
+int test02A(int b, int *pA, char *pB, int *pC) {
+  int *__restrict prA;
+  prA = pA;
+  char *__restrict prB;
+  prB = pB;
+  char *lp = b ? (char *)prA : (char *)prB;
+
+  *lp = 42;
+  *pC = 43;
+  return *lp;
+}
+
+// CHECK: @test02B
+// CHECK: ret i32 42
+int test02B(int b, int *__restrict prA, char *__restrict prB, int *pC) {
+  char *lp = b ? (char *)prA : (char *)prB;
+
+  *lp = 42;
+  *pC = 43;
+  return *lp;
+}
+
+// CHECK: @test03
+// CHECK: ret i32 42
+int test03(int n, int *pA, char *pB, int *pC) {
+  do {
+    int *__restrict prA;
+    prA = pA;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *pA;
+}
+
+// CHECK: @test04A0
+// CHECK: ret i32 42
+int test04A0(int n, int *pA, char *pB, int *pC) {
+  int *__restrict prA;
+  do {
+    prA = pA;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *prA;
+}
+
+// CHECK: @test04A1
+// CHECK: ret i32 42
+int test04A1(int n, int *pA, char *pB, int *pC) {
+  int *__restrict prA;
+  prA = pA;
+  do {
+    prA = pA;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *prA;
+}
+
+// CHECK: @test04B0
+// CHECK: ret i32 42
+int test04B0(int n, int *__restrict prA, char *pB, int *pC) {
+  do {
+    prA = prA;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *prA;
+}
+
+// CHECK: @test04B1
+// CHECK: ret i32 42
+int test04B1(int n, int *__restrict prA, char *pB, int *pC) {
+  prA = prA;
+  do {
+    prA = prA;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *prA;
+}
+
+// CHECK: @test05A
+// CHECK: ret i32 42
+int test05A(int n, int *pA, char *pB, int *pC) {
+  int *__restrict prA;
+  prA = pA;
+  do {
+    prA++;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *prA;
+}
+
+// CHECK: @test05B
+// CHECK: ret i32 42
+int test05B(int n, int *__restrict prA, char *pB, int *pC) {
+  do {
+    prA++;
+
+    *prA = 42;
+    *pC = 43;
+  } while (n--);
+  return *prA;
+}

clang/test/CodeGen/restrict/basic_opt_02.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+int foo1(int *a, int *restrict b, int c) {
+  *a = 0;
+  *b = c;
+  return *a; // OK: returns 0
+}
+// CHECK: @foo1
+// CHECK: ret i32 0
+
+int foo2(int *a, int *restrict b, int c) {
+  int *bc = b + c;
+  *a = 0;
+  *bc = c;   // OK: bc keeps the restrictness
+  return *a; // returns 0
+}
+// CHECK: @foo2
+// CHECK: ret i32 0
+
+static int *copy(int *b) { return b; }
+
+int foo3(int *a, int *restrict b, int c) {
+  int *bc = copy(b); // a fix to support this is in the works
+  *a = 0;
+  *bc = c;
+  return *a;
+}
+// CHECK: @foo3
+// CHECK: ret i32 0
+
+// Finally:
+inline void update(int *p, int c) { *p = c; }
+
+int foo6(int *a, int *b, int c) {
+  int *restrict bc = b; // local restrict
+  *a = 0;
+  update(bc, c); // Oops: inlining loses local restrict annotation
+  return *a;
+}
+
+// CHECK: @foo6
+// CHECK: ret i32 0
+
+// Notice the difference with:
+int foo7(int *a, int *restrict b, int c) {
+  *a = 0;
+  update(b, c); // restrict argument preserved after inlining.
+  return *a;    // returns 0
+}
+
+// CHECK: @foo7
+// CHECK: ret i32 0

clang/test/CodeGen/restrict/basic_opt_03.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// XFAIL: *
+
+// NOTE: SROA needs to be able to see through <tt>llvm.noalias</tt>. This is introduced in case of returning of larger structs.
+struct A {
+  int a, b, c, d, e, f, g, h;
+};
+struct A constructIt(int a) {
+  struct A tmp = {a, a, a, a, a, a, a, a};
+  return tmp;
+}
+int test_sroa01a(unsigned c) {
+  int tmp = 0;
+  for (int i = 0; i < c; ++i) {
+    struct A a = constructIt(i);
+    tmp = tmp + a.e;
+  }
+  return tmp;
+}
+
+// CHECK: @test_sroa01a
+// CHECK: FIXME
+
+int test_sroa01b(unsigned c) {
+  int tmp = 0;
+  for (int i = 0; i < c; ++i) {
+    struct A a = {i, i, i, i, i, i, i, i};
+    tmp = tmp + a.e;
+  }
+  return tmp;
+}
+
+// CHECK: @test_sroa01b
+// CHECK: FIXME
+
+int test_sroa01c(unsigned c) {
+  int tmp = 0;
+  for (int i = 0; i < c; ++i) {
+    int *__restrict dummy; // should not influence optimizations !
+    struct A a = {i, i, i, i, i, i, i, i};
+    tmp = tmp + a.e;
+  }
+  return tmp;
+}
+
+// CHECK: @test_sroa01b
+// CHECK: FIXME
+
+int test_sroa02a(unsigned c) {
+  int tmp = 0;
+  struct A a;
+  for (int i = 0; i < c; ++i) {
+    a = constructIt(i);
+    tmp = tmp + a.e;
+  }
+  return tmp;
+}
+
+// CHECK: @test_sroa02a
+// CHECK: FIXME
+
+int test_sroa02b(unsigned c) {
+  struct A a;
+  int tmp = 0;
+  for (int i = 0; i < c; ++i) {
+    a = (struct A){i, i, i, i, i, i, i, i};
+    tmp = tmp + a.e;
+  }
+  return tmp;
+}
+
+// CHECK: @test_sroa02b
+// CHECK: FIXME

clang/test/CodeGen/restrict/basic_opt_04.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// verify effect of restrict on optimizations
+void dummy_restrict01_n(int *p) {
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict01_a(int *__restrict p) {
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict01_r(int *p_) {
+  int *__restrict p = p_;
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict01_R(int *p_) {
+  int *__restrict p;
+  p = p_;
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict02_n(int *p) {
+  p++;
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict02_a(int *__restrict p) {
+  p++;
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict02_r(int *p_) {
+  int *__restrict p = p_;
+  p++;
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+void dummy_restrict02_R(int *p_) {
+  int *__restrict p;
+  p = p_;
+  p++;
+  if (0) {
+    *p = 0xdeadbeef;
+  }
+}
+
+// ---------------------------------
+
+int test01_n(int *pA, int c) {
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+
+// CHECK: @test01_n
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_a(int *__restrict pA, int c) {
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+
+// CHECK: @test01_a
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_r(int *pA_, int c) {
+  int *__restrict pA = pA_;
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+// CHECK: @test01_r
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_R(int *pA_, int c) {
+  int *__restrict pA;
+  pA = pA_;
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+// CHECK: @test01_R
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_nn(int *pA, int c) {
+  dummy_restrict01_n(pA);
+  return c;
+}
+// CHECK: @test01_nn
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_na(int *pA, int c) {
+  dummy_restrict01_a(pA);
+  return c;
+}
+// CHECK: @test01_na
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_nr(int *pA, int c) {
+  dummy_restrict01_r(pA);
+  return c;
+}
+// CHECK: @test01_nr
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test01_nR(int *pA, int c) {
+  dummy_restrict01_R(pA);
+  return c;
+}
+// CHECK: @test01_nR
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+// ----------------------------------
+int test02_n(int *pA, int c) {
+  pA++;
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+// CHECK: @test02_n
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_a(int *__restrict pA, int c) {
+  pA++;
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+// CHECK: @test02_a
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_r(int *pA_, int c) {
+  int *__restrict pA = pA_;
+  pA++;
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+// CHECK: @test02_r
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_R(int *pA_, int c) {
+  int *__restrict pA;
+  pA = pA_;
+  pA++;
+  if (0) {
+    *pA = 0xdeadbeef;
+  }
+  return c;
+}
+// CHECK: @test02_R
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_nn(int *pA, int c) {
+  dummy_restrict02_n(pA);
+  return c;
+}
+// CHECK: @test02_nn
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_na(int *pA, int c) {
+  dummy_restrict02_a(pA);
+  return c;
+}
+// CHECK: @test02_na
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_nr(int *pA, int c) {
+  dummy_restrict02_r(pA);
+  return c;
+}
+// CHECK: @test02_nr
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test02_nR(int *pA, int c) {
+  dummy_restrict02_R(pA);
+  return c;
+}
+// CHECK: @test02_nR
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test11_n(int *pA) {
+  unsigned total = 0;
+  for (int i = 0; i < 10; ++i) {
+    int *p = pA;
+    total = total + 1;
+  }
+  return total;
+}
+// CHECK: @test11_n
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test11_lr(int *pA) {
+  unsigned total = 0;
+  for (int i = 0; i < 10; ++i) {
+    int *__restrict p = pA;
+    total = total + 1;
+  }
+  return total;
+}
+// CHECK: @test11_lr
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test11_lR(int *pA) {
+  unsigned total = 0;
+  for (int i = 0; i < 10; ++i) {
+    int *__restrict p;
+    p = pA;
+    total = total + 1;
+  }
+  return total;
+}
+// CHECK: @test11_lR
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test12_n(int *pA) {
+  unsigned total = 0;
+  for (int i = 0; i < 10; ++i) {
+    int *p = pA;
+    p++;
+    total = total + 1;
+  }
+  return total;
+}
+// CHECK: @test12_n
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test12_lr(int *pA) {
+  unsigned total = 0;
+  for (int i = 0; i < 10; ++i) {
+    int *__restrict p = pA;
+    p++;
+    total = total + 1;
+  }
+  return total;
+}
+// CHECK: @test12_lr
+// CHECK-NOT: .noalias
+// CHECK: ret i32
+
+int test12_lR(int *pA) {
+  unsigned total = 0;
+  for (int i = 0; i < 10; ++i) {
+    int *__restrict p;
+    p = pA;
+    p++;
+    total = total + 1;
+  }
+  return total;
+}
+// CHECK: @test12_lR
+// CHECK-NOT: .noalias
+// CHECK: ret i32

clang/test/CodeGen/restrict/escape_through_volatile.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// a <tt>volatile</tt> pointer can confuse llvm: (p2 depends on p0)
+int test_escape_through_volatile_01(int *a_p0) {
+  int *__restrict p0;
+  p0 = a_p0;
+  int *volatile p1 = p0;
+  int *p2 = p1;
+  *p0 = 42;
+  *p2 = 99;
+
+  return *p0; // 42 or 99
+}
+
+// CHECK: @test_escape_through_volatile_01
+// either a reload or 99, but must never be 42
+// CHECK-NOT: ret i32 42
+
+// but not in:
+int test_escape_through_volatile_02(int *__restrict p0) {
+  int *volatile p1 = p0;
+  int *p2 = p1;
+  *p0 = 42;
+  *p2 = 99;
+
+  return *p0; // 42 or 99
+}
+
+// CHECK: @test_escape_through_volatile_02
+// either a reload or 99, but must never be 42
+// CHECK-NOT: ret i32 42

clang/test/CodeGen/restrict/inlining_01.c

+// sfg-check: check resulting chains
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// check how restrict propagation wrt inlining works
+
+//#define INLINE __attribute__((alwaysinline))
+//#define INLINE inline
+#define INLINE
+
+// Variations:
+// - n : no restrict
+// - a : argument restrict
+// - R : local restrict
+
+#define ARGRESTRICT_n
+#define ARGRESTRICT_a __restrict
+#define ARGRESTRICT_R
+
+#define LOCALRESTRICT_n(T, A, B) T A = B
+#define LOCALRESTRICT_a(T, A, B) T A = B
+#define LOCALRESTRICT_R(T, A, B) T __restrict A = B
+
+#define CREATE_ALL(CS) \
+  CS(n, n)             \
+  CS(a, n)             \
+  CS(n, a)             \
+  CS(a, a)             \
+  CS(R, n)             \
+  CS(n, R)             \
+  CS(R, R)
+
+#define CREATE_SET(A, B)                                                    \
+  INLINE int set_##A##B(int *ARGRESTRICT_##A pA, int *ARGRESTRICT_##B pB) { \
+    LOCALRESTRICT_##A(int *, lpA, pA);                                      \
+    LOCALRESTRICT_##B(int *, lpB, pB);                                      \
+    *lpA = 42;                                                              \
+    *lpB = 99;                                                              \
+    return *lpA;                                                            \
+  }
+
+#define CREATE_CALL_SET1(A, B)                      \
+  int test01_nn_call_set_##A##B(int *pA, int *pB) { \
+    set_##A##B(pA, pB);                             \
+    return *pA;                                     \
+  }
+
+#define CREATE_CALL_SET2(A, B)                                                            \
+  int test02_##A##B##_call_set_##A##B(int *ARGRESTRICT_##A pA, int *ARGRESTRICT_##B pB) { \
+    LOCALRESTRICT_##A(int *, lpA, pA);                                                    \
+    LOCALRESTRICT_##B(int *, lpB, pB);                                                    \
+    set_##A##B(lpA, lpB);                                                                 \
+    return *lpA;                                                                          \
+  }
+
+#define CREATE_CALL_SET3(A, B)                                                        \
+  int test03_##A##B##_call_set_nn(int *ARGRESTRICT_##A pA, int *ARGRESTRICT_##B pB) { \
+    LOCALRESTRICT_##A(int *, lpA, pA);                                                \
+    LOCALRESTRICT_##B(int *, lpB, pB);                                                \
+    set_nn(lpA, lpB);                                                                 \
+    return *lpA;                                                                      \
+  }
+
+CREATE_ALL(CREATE_SET)
+CREATE_ALL(CREATE_CALL_SET1)
+CREATE_ALL(CREATE_CALL_SET2)
+CREATE_ALL(CREATE_CALL_SET3)
+
+// CHECK-LABEL: @set_nn(
+// CHECK-NOT: ret i32 42
+
+// CHECK-LABEL: @set_an(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @set_na(
+// CHECK: ret i32 42
+
+// CHECK_LABEL: @set_aa(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @set_Rn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @set_nR(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @set_RR(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test01_nn_call_set_nn(
+// CHECK-NOT: ret i32 42
+
+//@ NOTE: missed store-load propagation
+// CHECK-LABEL: @test01_nn_call_set_an(
+// CHECK-NOT: ret i32 42
+
+//@ NOTE: missed store-load propagation
+// CHECK-LABEL: @test01_nn_call_set_na(
+// CHECK-NOT: ret i32 42
+
+//@ NOTE: missed store-load propagation
+// CHECK-LABEL: @test01_nn_call_set_aa(
+// CHECK-NOT: ret i32 42
+
+//@ NOTE: missed store-load propagation
+// CHECK-LABEL: @test01_nn_call_set_Rn(
+// CHECK-NOT: ret i32 42
+
+//@ NOTE: missed store-load propagation
+// CHECK-LABEL: @test01_nn_call_set_nR(
+// CHECK-NOT: ret i32 42
+
+//@ NOTE: missed store-load propagation
+// CHECK-LABEL: @test01_nn_call_set_RR(
+// CHECK-NOT: ret i32 42
+
+// CHECK-LABEL: @test02_nn_call_set_nn(
+// CHECK-NOT: ret i32 42
+
+// CHECK-LABEL: @test02_an_call_set_an(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test02_na_call_set_na(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test02_aa_call_set_aa(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test02_Rn_call_set_Rn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test02_nR_call_set_nR(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test02_RR_call_set_RR(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test03_nn_call_set_nn(
+// CHECK-NOT: ret i32 42
+
+// CHECK-LABEL: @test03_an_call_set_nn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test03_na_call_set_nn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test03_aa_call_set_nn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test03_Rn_call_set_nn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test03_nR_call_set_nn(
+// CHECK: ret i32 42
+
+// CHECK-LABEL: @test03_RR_call_set_nn(
+// CHECK: ret i32 42

clang/test/CodeGen/restrict/inlining_02.c

+// sfg-check: check resulting chains
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// Base test for restrict propagation with inlining
+
+//#define INLINE __attribute__((alwaysinline))
+//#define INLINE inline
+#define INLINE
+
+void set_nnn(int *pA, int *pB, int *dummy) {
+  int *lpA;
+  lpA = pA;
+  int *lpB;
+  lpB = pB;
+  int *ldummy;
+  ldummy = dummy;
+  *lpA = 42;
+  *lpB = 43;
+
+  *ldummy = 99;
+}
+// CHECK-LABEL: @set_nnn(
+
+void set_nna(int *pA, int *pB, int *__restrict dummy) {
+  int *lpA;
+  lpA = pA;
+  int *lpB;
+  lpB = pB;
+  int *ldummy;
+  ldummy = dummy;
+  *lpA = 42;
+  *lpB = 43;
+
+  *ldummy = 99;
+}
+// CHECK-LABEL: @set_nna(
+
+void set_nnr(int *pA, int *pB, int *dummy) {
+  int *lpA;
+  lpA = pA;
+  int *lpB;
+  lpB = pB;
+  int *__restrict ldummy;
+  ldummy = dummy;
+
+  *lpA = 42;
+  *lpB = 43;
+
+  *ldummy = 99;
+}
+// CHECK-LABEL: @set_nnr(
+
+int test_rr_nnn(int *pA, int *pB, int *dummy) {
+  int *__restrict lpA;
+  lpA = pA;
+  int *__restrict lpB;
+  lpB = pB;
+
+  set_nnn(lpA, lpB, dummy);
+  return *lpA;
+}
+
+// CHECK-LABEL: @test_rr_nnn(
+// CHECK: ret i32 42
+
+int test_rr_nna(int *pA, int *pB, int *dummy) {
+  int *__restrict lpA;
+  lpA = pA;
+  int *__restrict lpB;
+  lpB = pB;
+
+  set_nna(lpA, lpB, dummy);
+  return *lpA;
+}
+
+// CHECK-LABEL: @test_rr_nna(
+// CHECK: ret i32 42
+
+int test_rr_nnr(int *pA, int *pB, int *dummy) {
+  int *__restrict lpA;
+  lpA = pA;
+  int *__restrict lpB;
+  lpB = pB;
+
+  set_nnr(lpA, lpB, dummy);
+  return *lpA;
+}
+
+// CHECK-LABEL: @test_rr_nnr(
+// CHECK: ret i32 42
+
+// -----------------------------------------------------------
+
+int test_rr_local_nnn(int *pA, int *pB, int *dummy) {
+  int *__restrict lpA;
+  lpA = pA;
+  int *__restrict lpB;
+  lpB = pB;
+  int *ldummy;
+  ldummy = dummy;
+
+  *lpA = 10;
+  {
+    int *l2pA;
+    l2pA = lpA;
+    int *l2pB;
+    l2pB = lpB;
+    int *l2dummy;
+    l2dummy = ldummy;
+    *l2pA = 42;
+    *l2pB = 43;
+
+    *l2dummy = 99;
+  }
+  return *lpA;
+}
+// CHECK-LABEL: @test_rr_local_nnn(
+// CHECK: ret i32 42
+
+int test_rr_local_nnr(int *pA, int *pB, int *dummy) {
+  int *__restrict lpA;
+  lpA = pA;
+  int *__restrict lpB;
+  lpB = pB;
+  int *ldummy;
+  ldummy = dummy;
+
+  *lpA = 10;
+  {
+    int *l2pA;
+    l2pA = lpA;
+    int *l2pB;
+    l2pB = lpB;
+    int *__restrict l2dummy;
+    l2dummy = ldummy;
+    *l2pA = 42;
+    *l2pB = 43;
+
+    *l2dummy = 99;
+  }
+  return *lpA;
+}
+// CHECK-LABEL: @test_rr_local_nnr(
+// CHECK: ret i32 42

clang/test/CodeGen/restrict/provenance.noalias_reduction_01.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict -fno-experimental-new-pass-manager %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict -fexperimental-new-pass-manager %s -emit-llvm -o - | FileCheck %s
+
+// Check that unnecessary llvm.provenance.noalias calls are collapsed
+
+int *test01(int *p, int n) {
+  int *__restrict rp;
+  rp = p;
+  for (int i = 0; i < n; ++i) {
+    *rp = 10;
+    rp++;
+    rp++;
+    rp++;
+    rp++;
+  }
+  return rp;
+}
+
+// CHECK-LABEL:  @test01(
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.provenance.noalias
+
+int *test02(int *p, int n) {
+  int *__restrict rp;
+  rp = p;
+  rp++;
+  rp++;
+  rp++;
+  rp++;
+  for (int i = 0; i < n; ++i) {
+    *rp = 10;
+    rp++;
+    rp++;
+    rp++;
+    rp++;
+  }
+  return rp;
+}
+
+// CHECK-LABEL: @test02(
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.provenance.noalias
+
+int *test03(int *p, int n) {
+  int *__restrict rp;
+  rp = p;
+  rp++;
+  rp++;
+  rp++;
+  rp++;
+  for (int i = 0; i < n; ++i) {
+    *rp = 10;
+    rp++;
+    rp++;
+    if (*rp == 42) {
+      rp++;
+      rp++;
+    }
+    rp++;
+    rp++;
+  }
+  return rp;
+}
+
+// CHECK-LABEL: @test03(
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.provenance.noalias
+
+int *test04(int *p, int n) {
+  int *__restrict rp;
+  rp = p;
+  rp++;
+  rp++;
+  rp++;
+  rp++;
+  for (int i = 0; i < n; ++i) {
+    *rp = 10;
+    rp++;
+    rp++;
+    switch (*rp) {
+    default:
+      rp++;
+    case 10:
+      rp++;
+    case 20:
+      rp++;
+    case 30:
+      rp++;
+      break;
+    }
+    if (*rp == 42) {
+      rp++;
+      rp++;
+    }
+    rp++;
+    rp++;
+  }
+  return rp;
+}
+
+// CHECK-LABEL: @test04(
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.provenance.noalias
+
+int *test05(int *p, int n) {
+  int *__restrict rp;
+  rp = p;
+  rp++;
+  rp++;
+  rp++;
+  rp++;
+  for (int i = 0; i < n; ++i) {
+    *rp = 10;
+    rp++;
+    rp++;
+    switch (*rp) {
+    default:
+      rp++;
+    case 10:
+      rp++;
+    case 20:
+      rp++;
+    case 30:
+      rp++;
+      break;
+    }
+    if (*rp == 42) {
+      rp++;
+      rp++;
+    }
+    rp++;
+    rp++;
+  }
+  return rp;
+}
+
+// CHECK-LABEL: @test05(
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.provenance.noalias
+
+int *test06(int *p, int n) {
+  int *__restrict rp1;
+  rp1 = p;
+  // llvm.provenance.noalias rp1 (p)
+
+  {
+    int *__restrict rp;
+    rp = p;
+    // llvm.provenance.noalias rp (p)
+    // llvm.provenance.noalias rp (rp1)
+    rp++;
+    rp++;
+    rp++;
+    rp++;
+    for (int i = 0; i < n; ++i) {
+      *rp = 10;
+      rp = rp1;
+      rp++;
+      rp++;
+
+      switch (*rp) {
+      default:
+        rp++;
+      case 10:
+        rp++;
+      case 20:
+        rp++;
+      case 30:
+        rp++;
+        break;
+      }
+      if (*rp == 42) {
+        rp++;
+        rp++;
+      }
+      rp++;
+      rp++;
+    }
+    // llvm.provenance.noalias rp (p -> (p || rp1))
+    return rp;
+  }
+}
+
+// CHECK-LABEL: @test06(
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.provenance.noalias
+
+// CHECK: declare i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64

clang/test/CodeGen/restrict/struct.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-optzns -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+int r;
+void ex1(int *);
+
+struct FOO {
+  int *restrict rp0;
+  int *restrict rp1;
+  int *restrict rp2;
+};
+
+void test_FOO_local(int *pA, int *pB, int *pC) {
+  struct FOO tmp = {pA, pB, pC};
+  *tmp.rp0 = 42;
+  *tmp.rp1 = 43;
+}
+// CHECK-LABEL: void @test_FOO_local(
+// CHECK:  [[tmp:%.*]] = alloca %struct.FOO, align 8
+// CHECK:  [[TMP1:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0s_struct.FOOs.i64(%struct.FOO* [[tmp]], i64 0, metadata [[TAG_6:!.*]])
+// CHECK:  [[rp0:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[tmp]], i32 0, i32 0
+// CHECK:  [[rp01:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[tmp]], i32 0, i32 0
+// CHECK:  [[TMP5:%.*]] = load i32*, i32** [[rp01]], align 8, !tbaa [[TAG_9:!.*]], !noalias [[TAG_6]]
+// CHECK:  [[TMP6:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP5]], i8* [[TMP1]], i32** [[rp01]], i64 0, metadata [[TAG_6]]), !tbaa [[TAG_9]], !noalias [[TAG_6]]
+// CHECK:  store i32 42, i32* [[TMP6]], align 4, !tbaa [[TAG_13:!.*]], !noalias [[TAG_6]]
+// CHECK:  [[rp12:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[tmp]], i32 0, i32 1
+// CHECK:  [[TMP7:%.*]] = load i32*, i32** [[rp12]], align 8, !tbaa [[TAG_11:!.*]], !noalias [[TAG_6]]
+// CHECK:  [[TMP8:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP7]], i8* [[TMP1]], i32** [[rp12]], i64 0, metadata [[TAG_6]]), !tbaa [[TAG_11]], !noalias [[TAG_6]]
+// CHECK:  store i32 43, i32* [[TMP8]], align 4, !tbaa [[TAG_13]], !noalias [[TAG_6]]
+// CHECK:  ret void
+
+void test_FOO_arg_pointer(struct FOO *p) {
+  *p->rp0 = 42;
+  *p->rp1 = 43;
+}
+
+// define void @test_FOO_arg_pointer(%struct.FOO* %p) #0 !noalias !15 {
+// CHECK: void @test_FOO_arg_pointer(%struct.FOO* [[p:%.*]]) #0 !noalias [[TAG_15:!.*]] {
+// CHECK:       [[p_addr:%.*]] = alloca %struct.FOO*, align 8
+// CHECK-NEXT:  store %struct.FOO* [[p]], %struct.FOO** [[p_addr]], align 8, !tbaa [[TAG_2:!.*]], !noalias [[TAG_15]]
+// CHECK-NEXT:  [[TMP0:%.*]] = load %struct.FOO*, %struct.FOO** [[p_addr]], align 8, !tbaa [[TAG_2]], !noalias [[TAG_15]]
+// CHECK-NEXT:  [[rp0:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[TMP0]], i32 0, i32 0
+// CHECK-NEXT:  [[TMP1:%.*]] = load i32*, i32** [[rp0]], align 8, !tbaa [[TAG_9:!.*]], !noalias [[TAG_15]]
+// CHECK-NEXT:  [[TMP2:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP1]], i8* null, i32** [[rp0]], i64 0, metadata [[TAG_15]]), !tbaa [[TAG_9]], !noalias [[TAG_15]]
+// CHECK-NEXT:  store i32 42, i32* [[TMP2]], align 4, !tbaa [[TAG_13:!.*]], !noalias [[TAG_15]]
+// CHECK-NEXT:  [[TMP3:%.*]] = load %struct.FOO*, %struct.FOO** [[p_addr]], align 8, !tbaa [[TAG_2]], !noalias [[TAG_15]]
+// CHECK-NEXT:  [[rp1:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[TMP3]], i32 0, i32 1
+// CHECK-NEXT:  [[TMP4:%.*]] = load i32*, i32** [[rp1]], align 8, !tbaa [[TAG_11:!.*]], !noalias [[TAG_15]]
+// CHECK-NEXT:  [[TMP5:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP4]], i8* null, i32** [[rp1]], i64 0, metadata [[TAG_15]]), !tbaa [[TAG_11]], !noalias [[TAG_15]]
+// CHECK-NEXT:  store i32 43, i32* [[TMP5]], align 4, !tbaa [[TAG_13]], !noalias [[TAG_15]]
+// CHECK-NEXT:  ret void
+
+void test_FOO_arg_value(struct FOO p) {
+  *p.rp0 = 42;
+  *p.rp1 = 43;
+}
+// NOTE: the struct is mapped 'byval', the scope will be introduced after inlining.
+
+// define void @test_FOO_arg_value(%struct.FOO* byval(%struct.FOO) align 8 %p) #0 !noalias !18 {
+// CHECK: void @test_FOO_arg_value(%struct.FOO* byval(%struct.FOO) align 8 %p) #0 !noalias [[TAG_18:!.*]] {
+// CHECK:       [[rp0:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[p:%.*]], i32 0, i32 0
+// CHECK-NEXT:  [[TMP0:%.*]] = load i32*, i32** [[rp0]], align 8, !tbaa [[TAG_9:!.*]], !noalias [[TAG_18]]
+// CHECK-NEXT:  [[TMP1:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP0]], i8* null, i32** [[rp0]], i64 0, metadata [[TAG_18]]), !tbaa [[TAG_9]], !noalias [[TAG_18]]
+// CHECK-NEXT:  store i32 42, i32* [[TMP1]], align 4, !tbaa [[TAG_13:!.*]], !noalias [[TAG_18]]
+// CHECK-NEXT:  [[rp1:%.*]] = getelementptr inbounds %struct.FOO, %struct.FOO* [[p]], i32 0, i32 1
+// CHECK-NEXT:  [[TMP2:%.*]] = load i32*, i32** [[rp1]], align 8, !tbaa [[TAG_11:!.*]], !noalias [[TAG_18]]
+// CHECK-NEXT:  [[TMP3:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP2]], i8* null, i32** [[rp1]], i64 0, metadata [[TAG_18]]), !tbaa [[TAG_11]], !noalias [[TAG_18]]
+// CHECK-NEXT:  store i32 43, i32* [[TMP3]], align 4, !tbaa [[TAG_13]], !noalias [[TAG_18]]
+// CHECK-NEXT:  ret void
+
+struct FOO test_FOO_pass(struct FOO p) {
+  return p;
+}
+
+// define void @test_FOO_pass(%struct.FOO* noalias sret(%struct.FOO) align 8 %agg.result, %struct.FOO* byval(%struct.FOO) align 8 %p) #0 !noalias !21 {
+// CHECK: void @test_FOO_pass(%struct.FOO* noalias sret(%struct.FOO) align 8 %agg.result, %struct.FOO* byval(%struct.FOO) align 8 %p) #0 !noalias [[TAG_21:!.*]] {
+// CHECK:       [[TMP0:%.*]] = call %struct.FOO* @llvm.noalias.copy.guard.p0s_struct.FOOs.p0i8(%struct.FOO* [[p:%.*]], i8* null, metadata [[TAG_24:!.*]], metadata [[TAG_21]])
+// CHECK-NEXT:  [[TMP1:%.*]] = bitcast %struct.FOO* [[agg_result:%.*]] to i8*
+// CHECK-NEXT:  [[TMP2:%.*]] = bitcast %struct.FOO* [[TMP0]] to i8*
+// CHECK-NEXT:  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[TMP1]], i8* align 8 [[TMP2]], i64 24, i1 false), !tbaa.struct [[TAG_28:!.*]], !noalias [[TAG_21]]
+// CHECK-NEXT:  ret void
+
+struct FUM {
+  struct FOO m;
+};
+
+void test_FUM_local(int *pA, int *pB, int *pC) {
+  struct FUM tmp = {{pA, pB, pC}};
+  *tmp.m.rp0 = 42;
+  *tmp.m.rp1 = 43;
+}
+
+// CHECK-LABEL: void @test_FUM_local(
+// CHECK:  [[TMP1:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0s_struct.FUMs.i64(%struct.FUM* [[tmp]], i64 0, metadata [[TAG_29:!.*]])
+// CHECK:  [[TMP6:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP5:%.*]], i8* [[TMP1]], i32** [[rp02:%.*]], i64 0, metadata [[TAG_29]]), !tbaa [[TAG_32:!.*]], !noalias [[TAG_29]]
+// CHECK:  [[TMP8:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP7:%.*]], i8* [[TMP1]], i32** [[rp14:%.*]], i64 0, metadata [[TAG_29]]), !tbaa [[TAG_34:!.*]], !noalias [[TAG_29]]
+
+void test_FUM_arg_pointer(struct FUM *p) {
+  *p->m.rp0 = 42;
+  *p->m.rp1 = 43;
+}
+// define void @test_FUM_arg_pointer(%struct.FUM* %p) #0 !noalias !35 {
+// CHECK: void @test_FUM_arg_pointer(%struct.FUM* [[p:%.*]]) #0 !noalias [[TAG_35:!.*]] {
+// CHECK:  [[TMP2:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP1:%.*]], i8* null, i32** [[rp0:%.*]], i64 0, metadata [[TAG_35]]), !tbaa [[TAG_32:!.*]], !noalias [[TAG_35]]
+// CHECK:  [[TMP5:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP4:%.*]], i8* null, i32** [[rp1:%.*]], i64 0, metadata [[TAG_35]]), !tbaa [[TAG_34:!.*]], !noalias [[TAG_35]]
+
+void test_FUM_arg_value(struct FUM p) {
+  *p.m.rp0 = 42;
+  *p.m.rp1 = 43;
+}
+
+// define void @test_FUM_arg_value(%struct.FUM* byval(%struct.FUM) align 8 %p) #0 !noalias !38 {
+// CHECK: void @test_FUM_arg_value(%struct.FUM* byval(%struct.FUM) align 8 %p) #0 !noalias [[TAG_38:!.*]] {
+// CHECK:  [[TMP1:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP0:%.*]], i8* null, i32** [[rp0:%.*]], i64 0, metadata [[TAG_38]]), !tbaa [[TAG_32:!.*]], !noalias [[TAG_38]]
+// CHECK:  [[TMP3:%.*]] = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i64(i32* [[TMP2:%.*]], i8* null, i32** [[rp1:%.*]], i64 0, metadata [[TAG_38]]), !tbaa [[TAG_34:!.*]], !noalias [[TAG_38]]
+
+struct FUM test_FUM_pass(struct FUM p) {
+  return p;
+}
+
+// define void @test_FUM_pass(%struct.FUM* noalias sret(%struct.FUM) align 8 %agg.result, %struct.FUM* byval(%struct.FUM) align 8 %p) #0 !noalias !41 {
+// CHECK: void @test_FUM_pass(%struct.FUM* noalias sret(%struct.FUM) align 8 %agg.result, %struct.FUM* byval(%struct.FUM) align 8 %p) #0 !noalias [[TAG_41:!.*]] {
+// CHECK:       [[TMP0:%.*]] = call %struct.FUM* @llvm.noalias.copy.guard.p0s_struct.FUMs.p0i8(%struct.FUM* [[p:%.*]], i8* null, metadata [[TAG_44:!.*]], metadata [[TAG_41]])
+// CHECK-NEXT:  [[TMP1:%.*]] = bitcast %struct.FUM* [[agg_result:%.*]] to i8*
+// CHECK-NEXT:  [[TMP2:%.*]] = bitcast %struct.FUM* [[TMP0]] to i8*
+// CHECK-NEXT:  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[TMP1]], i8* align 8 [[TMP2]], i64 24, i1 false), !tbaa.struct [[TAG_28:!.*]], !noalias [[TAG_41]]
+// CHECK-NEXT:  ret void
+
+// indices for llvm.noalias.copy.guard
+
+// CHECK: [[TAG_24]] = !{[[TAG_25:!.*]], [[TAG_26:!.*]], [[TAG_27:!.*]]}
+// CHECK: [[TAG_25]] = !{i32 -1, i32 0}
+// CHECK: [[TAG_26]] = !{i32 -1, i32 1}
+// CHECK: [[TAG_27]] = !{i32 -1, i32 2}
+
+// CHECK: [[TAG_44]] = !{[[TAG_45:!.*]], [[TAG_46:!.*]], [[TAG_47:!.*]]}
+// CHECK: [[TAG_45]] = !{i32 -1, i32 0, i32 0}
+// CHECK: [[TAG_46]] = !{i32 -1, i32 0, i32 1}
+// CHECK: [[TAG_47]] = !{i32 -1, i32 0, i32 2}

clang/test/CodeGen/restrict/struct_member_01.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+struct FOO {
+  int *__restrict pA;
+  int *__restrict pB;
+};
+
+int test00a(int *pA, int *pB) {
+  int *__restrict rpA;
+  int *__restrict rpB;
+  rpA = pA;
+  rpB = pB;
+
+  *rpA = 42;
+  *rpB = 43;
+  return *rpA;
+}
+
+// CHECK-LABEL: @test00a(
+// CHECK: ret i32 42
+
+int test00b(int *pA, int *pB) {
+  int *__restrict rp[2];
+  rp[0] = pA;
+  rp[1] = pB;
+
+  *rp[0] = 42;
+  *rp[1] = 43;
+  return *rp[0];
+}
+
+// CHECK-LABEL: @test00b(
+// CHECK: ret i32 42
+
+int test01(struct FOO *p0, struct FOO *p1) {
+  *p0->pA = 42;
+  *p1->pA = 43;
+
+  return *p0->pA; // 42 or 43
+}
+// CHECK-LABEL: @test01(
+// CHECK-NOT: ret i32 42
+
+int test11(struct FOO *p0, struct FOO *p1) {
+  *p0->pA = 42;
+  *p1->pB = 43;
+
+  return *p0->pA; // 42
+}
+
+// CHECK-LABEL: @test11(
+// CHECK: ret i32 42
+
+int test21(struct FOO p0, struct FOO p1) {
+  *p0.pA = 42;
+  *p1.pB = 43;
+
+  return *p0.pA; // 42
+}
+
+// CHECK-LABEL: @test21(
+// CHECK: ret i32 42
+
+int test31(struct FOO *p0, struct FOO *__restrict p1) {
+  *p0->pA = 42;
+  *p1->pA = 43;
+
+  return *p0->pA; // 42
+}
+
+// CHECK-LABEL: @test31(
+// CHECK: ret i32 42

clang/test/CodeGen/restrict/struct_member_02.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict  -disable-llvm-passes %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict  -disable-llvm-passes %s -emit-llvm -o - | FileCheck %s
+
+//#define __restrict volatile
+
+// this test checks for what variables a restrict scope is created
+
+struct FOO_ipp {
+  int **p;
+};
+
+struct FOO_irpp {
+  int *__restrict *p;
+};
+
+struct FOO_iprp {
+  int dummy;
+  int **__restrict p;
+};
+
+struct FOO_irprp {
+  int *__restrict *__restrict p;
+};
+
+struct FOO_NESTED {
+  struct FOO_iprp m;
+};
+
+struct FOO_NESTED_A {
+  struct FOO_iprp m[2][3][4];
+};
+
+typedef struct FOO_NESTED FUM;
+typedef int *__restrict t_irp;
+
+int foo(int **p) {
+  struct FOO_ipp m1;               // no
+  struct FOO_irpp m2;              // no
+  struct FOO_iprp m3;              // yes
+  struct FOO_irprp m4;             // yes
+  struct FOO_NESTED m5;            // yes
+  struct FOO_NESTED m6[2][4][5];   // yes
+  struct FOO_NESTED_A m7[2][4][5]; // yes
+  t_irp p0;                        // yes
+  FUM m8[3];                       // yes
+  int *a1[2];                      // no
+  int **a2[2];                     // no
+  int *__restrict *a3[2];          // no
+  int **__restrict a4[2];          // yes
+  int **__restrict a5[2][3][4];    // yes
+  int *__restrict *a6;             // no
+  m1.p = p;
+  m2.p = p;
+  m3.p = p;
+  m4.p = p;
+  a1[0] = *p;
+  a1[1] = *p;
+
+  return **m1.p + **m2.p + **m3.p + **m4.p + *a1[0] + *a1[1];
+}
+
+// check the scopes of various variables
+// CHECK-LABEL: @foo(
+
+// the local variables:
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK: alloca
+// CHECK-NOT: alloca
+
+// the local variables that have a restrict scope:
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK: llvm.noalias.decl
+// CHECK-NOT: llvm.noalias.decl
+// CHECK: ret i32
+
+// the restrict related metadata
+// CHECK: foo: unknown scope
+// CHECK-NEXT: foo
+// CHECK-NOT:  foo:
+// CHECK:      foo: m3
+// CHECK-NEXT: foo: m4
+// CHECK-NEXT: foo: m5
+// CHECK-NEXT: foo: m6
+// CHECK-NEXT: foo: m7
+// CHECK-NEXT: foo: p0
+// CHECK-NEXT: foo: m8
+// CHECK-NEXT: foo: a4
+// CHECK-NEXT: foo: a5
+// CHECK-NOT:  foo:

clang/test/CodeGen/restrict/struct_member_03.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+struct FOO {
+  int *__restrict pA;
+  int *__restrict pB;
+};
+
+int test10(int *pA, int *pB) {
+  struct FOO rp;
+  rp.pA = pA;
+  rp.pB = pB;
+
+  *rp.pA = 42;
+  *rp.pB = 99;
+
+  return *rp.pA; // 42
+}
+// CHECK-LABEL: @test10(
+// CHECK: ret i32 42
+
+int test11(struct FOO rp) {
+  *rp.pA = 42;
+  *rp.pB = 99;
+
+  return *rp.pA; // 42
+}
+// CHECK-LABEL: @test11(
+// CHECK: ret i32 42
+
+int test12(struct FOO *rp) {
+  *rp->pA = 42;
+  *rp->pB = 99;
+
+  return *rp->pA; // 42
+}
+// CHECK-LABEL: @test12(
+// CHECK: ret i32 42
+
+int test20(int *pA, int *pB) {
+  struct FOO rp0;
+  struct FOO rp1;
+  rp0.pB = pA;
+  rp1.pB = pB;
+
+  *rp0.pB = 42;
+  *rp1.pB = 99;
+
+  return *rp0.pB; // 42
+}
+// CHECK-LABEL: @test20(
+// CHECK: ret i32 42
+
+int test21(struct FOO rp0, struct FOO rp1) {
+  *rp0.pB = 42;
+  *rp1.pB = 99;
+
+  return *rp0.pB; // 42
+}
+// CHECK-LABEL: @test21(
+// CHECK: ret i32 42
+
+int test22(struct FOO *rp0, struct FOO *rp1) {
+  *rp0->pB = 42;
+  *rp1->pB = 99;
+
+  return *rp0->pB; // needs load
+}
+// CHECK-LABEL: @test22(
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 99
+
+int test23(struct FOO *rp0, struct FOO *rp1) {
+  *rp0->pA = 42;
+  *rp1->pB = 99;
+
+  return *rp0->pA; // 42, rp0->pA and rp1->pB are not overlapping
+}
+// CHECK-LABEL: @test23(
+// CHECK: ret i32 42
+
+int test24(struct FOO *__restrict rp0, struct FOO *rp1) {
+  *rp0->pB = 42;
+  *rp1->pB = 99;
+
+  return *rp0->pB; // 42
+}
+// CHECK-LABEL: @test24(
+// CHECK: ret i32 42
+
+int test25(struct FOO *p0, struct FOO *rp1) {
+  struct FOO *__restrict rp0;
+  rp0 = p0;
+  *rp0->pB = 42;
+  *rp1->pB = 99;
+
+  return *rp0->pB; // 42
+}
+// CHECK-LABEL: @test25(
+// CHECK: ret i32 42

clang/test/CodeGen/restrict/struct_member_04.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// restrict member pointers and inlining - basic functionality test
+
+struct FOO {
+  int *__restrict pA;
+  int *__restrict pB;
+};
+
+void setFOO(struct FOO *p) {
+  *p->pA = 42;
+  *p->pB = 43;
+}
+
+int test10(int *pA, int *pB, int *pC) {
+
+  *pA = 40;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    setFOO(&rp);
+
+    *pC = 99;
+    return *rp.pA; // 42
+  }
+}
+
+// CHECK-LABEL: @test10(
+// CHECK: ret i32 42
+
+int test11(int *pA, int *pB, int *pC) {
+
+  *pA = 40;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    setFOO(&rp);
+
+    *pC = 99;
+  }
+  return *pA; // 42 // should be, but llvm does not see it
+}
+
+// CHECK-LABEL: @test11(
+// CHECK-NOT: ret i32 40
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 43
+// CHECK-NOT: ret i32 99
+
+int test12(int *pA, int *pB, int *pC) {
+
+  *pA = 40;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    setFOO(&rp);
+  }
+
+  *pC = 99;
+  return *pA; // 42 or 99
+}
+
+// CHECK-LABEL: @test12(
+// CHECK-NOT: ret i32 40
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 43
+// CHECK-NOT: ret i32 99
+
+// out-of-function scope
+int getFOO(struct FOO *p) {
+  return *p->pA;
+}
+
+// fully defined
+int test20(int *pA, int *pC) {
+  *pA = 42;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    *pC = 99;
+    return getFOO(&rp);
+  }
+}
+// CHECK-LABEL: @test20(
+// CHECK: ret i32 42
+
+// fully defined
+int test21(int *pA, int *pC) {
+  *pA = 42;
+  *pC = 99;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    return getFOO(&rp);
+  }
+}
+
+// CHECK-LABEL: @test21(
+// CHECK: ret i32 %
+
+// mixed defined
+int test22(int *pA, struct FOO *pB0, int b0, int *pC) {
+  *pA = 42;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    *pC = 99;
+    return getFOO(b0 ? &rp : pB0);
+  }
+}
+// CHECK-LABEL: @test22(
+// CHECK: ret i32 %
+
+// mixed-mixed defined
+int test23(int *pA, struct FOO *pB0, int b0, struct FOO *pB1, int b1, int *pC) {
+  *pA = 41;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    *pC = 98;
+    return test22(pA, b1 ? &rp : pB0, b0, pC);
+  }
+}
+// CHECK-LABEL: @test23(
+// CHECK: ret i32 %
+
+// fully defined
+int test24(int *pA, int *pB0, int b0, int *pB1, int b1, int *pC) {
+  *pA = 40;
+  {
+    struct FOO fb0;
+    fb0.pA = pB0;
+    {
+      struct FOO fb1;
+      fb1.pA = pB1;
+
+      return test23(pA, &fb0, b0, &fb1, b1, pC);
+    }
+  }
+}
+
+// CHECK-LABEL: @test24(
+// CHECK: ret i32 %
+
+int test25(int *pA, int b0, int b1, int *pC) {
+  *pA = 40;
+  {
+    struct FOO fb0;
+    fb0.pA = pA;
+    {
+      struct FOO fb1;
+      fb1.pA = pA;
+
+      return test23(pA, &fb0, b0, &fb1, b1, pC);
+    }
+  }
+}
+
+// CHECK-LABEL: @test25(
+// FIXME: should be:  ret i32 42
+// CHECK: ret i32 %

clang/test/CodeGen/restrict/struct_member_05.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// restrict member pointers and inlining - basic functionality test
+
+struct FOO {
+  int *__restrict pA;
+  int *__restrict pB;
+};
+
+struct FOO_plain {
+  int *pA;
+  int *pB;
+};
+
+int test10(int *pA, int *pB, int *pC) {
+
+  *pA = 40;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    {
+      struct FOO *p = &rp;
+      *p->pA = 42;
+      *p->pB = 43;
+    }
+
+    *pC = 99;
+    return *rp.pA; // 42
+  }
+}
+
+// CHECK-LABEL: @test10(
+// CHECK: ret i32 42
+
+int test11(int *pA, int *pB, int *pC) {
+
+  *pA = 40;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    {
+      *rp.pA = 42;
+      *rp.pB = 43;
+    }
+
+    *pC = 99;
+    return *rp.pA; // 42
+  }
+}
+
+// CHECK-LABEL: @test11(
+// CHECK: ret i32 42
+
+int test12a(int *pA, int *pB, int *pC, struct FOO *pF) {
+
+  *pA = 40;
+  {
+    struct FOO rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    {
+      struct FOO *p = pF ? pF : &rp;
+      *p->pA = 42;
+      *p->pB = 43;
+    }
+
+    *pC = 99;
+    return *rp.pA; // 42 or 40
+  }
+}
+
+// CHECK-LABEL: @test12a(
+// CHECK-NOT: ret i32 40
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 43
+// CHECK-NOT: ret i32 99
+
+int test12b(int *pA, int *pB, int *pC, struct FOO_plain *pF) {
+
+  *pA = 40;
+  {
+    struct FOO_plain rp;
+    rp.pA = pA;
+    rp.pB = pB;
+
+    {
+      struct FOO_plain *p = pF ? pF : &rp;
+      *p->pA = 42;
+      *p->pB = 43;
+    }
+
+    *pC = 99;
+    return *rp.pA; // 42 or 40 or 99 or ...
+  }
+}
+
+// CHECK-LABEL: @test12b(
+// CHECK-NOT: ret i32 40
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 43
+// CHECK-NOT: ret i32 99

clang/test/CodeGen/restrict/struct_member_06.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// restrict member pointers and inlining - basic functionality test
+
+struct FOO {
+  int *__restrict p;
+};
+
+struct FOO_plain {
+  int *pA;
+  int *pB;
+};
+
+int test01_p_pp(int c, int *pA, int *pB) {
+  int *__restrict rpA;
+  rpA = pA;
+  int *__restrict rpB;
+  rpB = pB;
+
+  int *p = c ? rpA : rpB;
+
+  return *p;
+}
+// CHECK-LABEL: @test01_p_pp(
+// CHECK:      @llvm.noalias.decl
+// CHECK-NEXT: @llvm.noalias.decl
+// CHECK-NEXT: icmp
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: select
+// CHECK-NEXT: select
+// CHECK-NEXT: load
+// CHECK-NEXT: ret i32
+
+int test01_p_ss(int c, int *pA, int *pB) {
+  struct FOO spA;
+  spA.p = pA;
+  struct FOO spB;
+  spB.p = pB;
+
+  int *p = c ? spA.p : spB.p;
+
+  return *p;
+}
+// CHECK-LABEL: @test01_p_ss(
+// CHECK:      @llvm.noalias.decl
+// CHECK-NEXT: @llvm.noalias.decl
+// CHECK-NEXT: icmp
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: select
+// CHECK-NEXT: select
+// CHECK-NEXT: load
+// CHECK-NEXT: ret i32
+
+int test01_s_ss(int c, int *pA, int *pB) {
+  struct FOO spA;
+  spA.p = pA;
+  struct FOO spB;
+  spB.p = pB;
+
+  {
+    struct FOO p = c ? spA : spB;
+
+    return *p.p;
+  }
+}
+// CHECK-LABEL: @test01_s_ss(
+// CHECK:      @llvm.noalias.decl
+// CHECK-NEXT: @llvm.noalias.decl
+// CHECK-NEXT: @llvm.noalias.decl
+// CHECK-NEXT: icmp
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: select
+// CHECK-NEXT: select
+// CHECK-NEXT: @llvm.provenance.noalias
+// CHECK-NEXT: load
+// CHECK-NEXT: ret i32
+
+// FIXME: this one currently results in bad code :(
+int test01_ps_ss(int c, int *pA, int *pB) {
+  struct FOO spA;
+  spA.p = pA;
+  struct FOO spB;
+  spB.p = pB;
+
+  struct FOO *p = c ? &spA : &spB;
+
+  return *p->p;
+}
+// CHECK-LABEL: @test01_ps_ss(
+// CHECK: ret i32
+
+int test01_ps_psps(int c, struct FOO *ppA, struct FOO *ppB) {
+  struct FOO *p = c ? ppA : ppB;
+
+  return *p->p;
+}
+// CHECK-LABEL: @test01_ps_psps(
+// CHECK: icmp
+// CHECK-NEXT: select
+// CHECK-NEXT: getelementptr
+// CHECK-NEXT: load
+// CHECK-NEXT: llvm.provenance.noalias
+// CHECK-NEXT: load
+// CHECK-NEXT: ret i32

clang/test/CodeGen/restrict/struct_member_07.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+struct FOO {
+  int *__restrict pA;
+};
+
+struct BAR {
+  int *pA;
+};
+
+static void adaptFOO(struct FOO *p) {
+  *p->pA = 99;
+};
+
+static void adaptBAR(struct BAR *p) {
+  *p->pA = 99;
+};
+
+static void adaptInt(int *p) {
+  *p = 99;
+};
+
+// has 'unknown scope': caller: no, callee: yes
+int test10(int *pA, struct FOO *pB) {
+  *pA = 42;
+  adaptFOO(pB);
+  return *pA;
+}
+// CHECK-LABEL: @test10(
+// CHECK: ret i32 42
+
+// has 'unknown scope': caller: yes, callee: no
+int test11(int *pA, struct FOO *pB) {
+  *pB->pA = 42;
+  adaptInt(pA);
+  return *pB->pA;
+}
+// CHECK-LABEL: @test11(
+// CHECK: ret i32 42
+
+// has 'unknown scope': caller: no, callee: no
+int test12(int *pA, struct BAR *pB) {
+  *pA = 42;
+  adaptBAR(pB);
+  return *pA;
+}
+// CHECK-LABEL: @test12(
+// CHECK-NOT: ret i32 42
+
+// has 'unknown scope': caller: yes, callee: yes
+int test13(int *pA, struct FOO *pB) {
+  *pB->pA = 41; // introduce 'unknown scope'
+  *pA = 42;
+  adaptFOO(pB);
+  return *pA;
+}
+
+// CHECK-LABEL: @test13(
+// CHECK: ret i32 42

clang/test/CodeGen/restrict/struct_member_08.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - -DDUMMY_BEFORE | FileCheck %s --check-prefixes=CHECK
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - -DDUMMY_BEFORE | FileCheck %s --check-prefixes=CHECK
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - -DDUMMY_AFTER | FileCheck %s --check-prefixes=CHECK
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - -DDUMMY_AFTER | FileCheck %s --check-prefixes=CHECK
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -ffull-restrict %s -emit-llvm -o - -DDUMMY_BEFORE -DDUMMY_AFTER | FileCheck %s --check-prefixes=CHECK
+// RUN: %clang_cc1 -triple i386-unknown-linux-gnu   -O2 -ffull-restrict %s -emit-llvm -o - -DDUMMY_BEFORE -DDUMMY_AFTER | FileCheck %s --check-prefixes=CHECK
+
+// NOTE: this test in C++ mode
+
+struct Fum {
+  Fum(unsigned long long d) {
+    ptr1 = ((int *)(d & 0xffffffff));
+    ptr2 = ((int *)((d >> 32) & 0xffffffff));
+  }
+  Fum(const Fum &) = default;
+
+#ifdef DUMMY_BEFORE
+  int *dummyb0;
+  int *dummyb1;
+#endif
+  int *__restrict ptr1;
+  int *__restrict ptr2;
+#ifdef DUMMY_AFTER
+  int *dummya0;
+  int *dummya1;
+#endif
+};
+
+static Fum pass(Fum d) { return d; }
+
+int test_Fum_01(unsigned long long data, int *p1) {
+  Fum tmp = {data};
+
+  int *p0 = tmp.ptr1;
+
+  *p0 = 42;
+  *p1 = 99;
+  return *p0;
+}
+// CHECK-LABEL: @_Z11test_Fum_01yPi
+// CHECK-NOT: alloca
+// CHECK: ret i32 42
+
+int test_Fum_02(unsigned long long data) {
+  Fum tmp = {data};
+
+  int *p0 = tmp.ptr1;
+  int *p1 = tmp.ptr2;
+
+  *p0 = 42;
+  *p1 = 99;
+  return *p0;
+}
+// CHECK-LABEL: @_Z11test_Fum_02y
+// CHECK-NOT: alloca
+// CHECK: ret i32 42
+
+int test_Fum_pass_01(unsigned long long data, int *p1) {
+  Fum tmp = {data};
+
+  int *p0 = pass(tmp).ptr1;
+
+  *p0 = 42;
+  *p1 = 99;
+  return *p0;
+}
+// CHECK-LABEL: @_Z16test_Fum_pass_01yPi
+// CHECK-NOT: alloca
+// CHECK: ret i32 42
+
+int test_Fum_pass_02(unsigned long long data) {
+  Fum tmp = {data};
+
+  int *p0 = pass(tmp).ptr1;
+  int *p1 = pass(tmp).ptr2;
+
+  *p0 = 42;
+  *p1 = 99;
+  return *p0;
+}
+// CHECK-LABEL: @_Z16test_Fum_pass_02y
+// CHECK-NOT: alloca
+// CHECK: ret i32 42
+
+int test_Fum_pass_03(unsigned long long data) {
+  Fum tmp = {data};
+
+  int *b0 = tmp.ptr1;
+  *b0 = 42;
+
+  int *p0 = pass(tmp).ptr1;
+
+  *p0 = 99;
+  return *b0; // 99
+}
+// CHECK-LABEL: @_Z16test_Fum_pass_03y
+// CHECK-NOT: alloca
+// CHECK-NOT: ret i32 42
+// CHECK: ret i32 99
+
+int test_Fum_pass_04(unsigned long long data, int *px) {
+  Fum tmp = {data};
+
+  int *b0 = tmp.ptr1;
+  *b0 = 42;
+  tmp.ptr1 = px;
+
+  int *p0 = pass(tmp).ptr1;
+
+  *p0 = 99;
+  return *b0; // 42 or 99
+}
+// CHECK-LABEL: @_Z16test_Fum_pass_04yPi
+// CHECK-NOT: alloca
+// CHECK-NOT: ret i32 42
+// CHECK-NOT: ret i32 99
+// CHECK: ret i32 %
+
+class S {
+public:
+  S(int *d) : data(d) {}
+  int *getData() { return data; }
+
+private:
+  int *__restrict__ data;
+};
+
+int test_S__01(int *pA, long N) {
+  int *__restrict__ x = pA;
+
+  *x = 42;
+  {
+    S s(x + N);
+    *s.getData() = 99;
+  }
+  return *x; // N could be 0
+}
+
+// CHECK-LABEL: @_Z10test_S__01Pil
+// CHECK-NOT: alloca
+// CHECK-NOT: ret i32 42
+// CHECK: ret i32 %
+
+int test_S__02(int *pA, long N) {
+  int *__restrict__ x = pA;
+
+  *x = 42;
+  {
+    S s(x + N);
+    *s.getData() = 99;
+    return *x; // restrict rules say that N cannot be 0
+  }
+}
+
+// CHECK-LABEL: @_Z10test_S__02Pil
+// CHECK-NOT: alloca
+// CHECK: ret i32 42