[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

115

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

115

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

1925

Use of Twine would probably be good here?

clang/lib/CodeGen/CodeGenFunction.cpp

666

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

def fno_force_enable_int128 : Flag<["-"], "fno-force-enable-int128">,
   Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable support for int128_t type">;
 def fkeep_static_consts : Flag<["-"], "fkeep-static-consts">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Keep static const variables even if unused">;
 def ffixed_point : Flag<["-"], "ffixed-point">, Group<f_Group>,
                    Flags<[CC1Option]>, HelpText<"Enable fixed point types">;
 def fno_fixed_point : Flag<["-"], "fno-fixed-point">, Group<f_Group>,
                       HelpText<"Disable fixed point types">;
+def ffull_restrict : Flag<["-"], "ffull-restrict">, Group<f_Group>,
+  Flags<[CoreOption, CC1Option]>,
+  HelpText<"Enable full restrict support">;
+def fno_full_restrict : Flag<["-"], "fno-full-restrict">, Group<f_Group>,
+  Flags<[CoreOption, CC1Option]>,
+  HelpText<"Disable full restrict support, falling back to the legacy support">;
+def fno_noalias_arguments : Flag<["-"], "fno-noalias-arguments">,
+  Group<f_Group>, Flags<[CoreOption, CC1Option]>,
+  HelpText<"Do not map restrict arguments onto noalias attribute">;
 def fcxx_static_destructors : Flag<["-"], "fc++-static-destructors">,
   Group<f_Group>,
   HelpText<"Enable C++ static destructor registration (the default)">;
 def fno_cxx_static_destructors : Flag<["-"], "fno-c++-static-destructors">,
   Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Disable C++ static destructor registration">;
 def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>,

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: {
             llvm::ConstantInt *AlignmentCI =
               cast<llvm::ConstantInt>(AlignmentValue);
             unsigned Alignment = std::min((unsigned)AlignmentCI->getZExtValue(),
                                           +llvm::Value::MaximumAlignment);
             AI->addAttrs(llvm::AttrBuilder().addAlignmentAttr(Alignment));
           }
         }
 
-        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);
 
         // LLVM expects swifterror parameters to be used in very restricted
         // ways.  Copy the value into a less-restricted temporary.
         if (FI.getExtParameterInfo(ArgNo).getABI()
               == ParameterABI::SwiftErrorResult) {
           QualType pointeeTy = Ty->getPointeeType();
           assert(pointeeTy->isPointerType());
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()
-                             : I->getKnownRValue().getAggregateAddress());
+        } else {
+          Address Addr = I->hasLValue()
+                             ? I->getKnownLValue().getAddress()
+                             : 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));
+          }
+        }
         IRCallArgs[FirstIRArg] =
           CreateCoercedLoad(Src, ArgInfo.getCoerceToType(), *this);
       }
 
       break;
     }
 
     case ABIArgInfo::CoerceAndExpand: {

clang/lib/CodeGen/CGDecl.cpp

emitStoresForConstant(
       type.isVolatileQualified(), Builder, constant);
 }
 
 // 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.
-void CodeGenFunction::EmitAutoVarNoAlias(const AutoVarEmission &emission) {
-  assert(emission.Variable && "emission was not valid!");
-
+// 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;
 
-  const VarDecl &D = *emission.Variable;
+  if (!CGM.getCodeGenOpts().FullRestrict)
+    return;
+
   QualType type = D.getType();
 
   // Emit a noalias intrinsic for restrict-qualified variables.
-  if (!type.isRestrictQualified())
+  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 = CurFn->getName();
-  Name += ": ";
-  Name += D.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 = emission.IsEscapingByRef && isCapturedBy(D, Init);
+  bool capturedByInit =
+      Init && emission.IsEscapingByRef && isCapturedBy(D, Init);
 
   Address Loc =
     capturedByInit ? emission.Addr : emission.getObjectAddress(*this);
-  NoAliasAddrMap[Loc.getPointer()] = ScopeList;
+  EmitNoAliasDecl(D, Loc);
 }
 
-// Emit an expression as an initializer for an object (variable, field, etc.)
+/// 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 loc the address to initialize; its type is a pointer
 ///   to the LLVM mapping of the object's type
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/ASTContext.h"
 #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 "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/Transforms/Utils/SanitizerStats.h"
 
 #include <string>
 
 using namespace clang;
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.
if (Ty->isVectorType()) {
       if (Addr.getElementType() != SrcTy) {
         Addr = Builder.CreateElementBitCast(Addr, SrcTy, "storetmp");
       }
     }
   }
 
   Value = EmitToMemory(Value, Ty);
 
-  // If this is an assignment to a restrict-qualified local variable, then we
-  // have pointer aliasing assumptions that can be applied to the pointer value
-  // being stored.
-  auto NAI = NoAliasAddrMap.find(Addr.getPointer());
-  if (NAI != NoAliasAddrMap.end())
-    Value = Builder.CreateNoAliasPointer(Value, NAI->second);
-
   LValue AtomicLValue =
       LValue::MakeAddr(Addr, Ty, getContext(), BaseInfo, TBAAInfo);
   if (Ty->isAtomicType() ||
       (!isInit && LValueIsSuitableForInlineAtomic(AtomicLValue))) {
     EmitAtomicStore(RValue::get(Value), AtomicLValue, isInit);
     return;
   }
 

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()) {
+    // NOTE: also see CodeGenFunction::EmitCall()
+    auto NoAliasScopeMD = getExistingOrUnknownNoAliasScope(SrcPtr.getPointer());
+    auto NoAliasDecl = getExistingNoAliasDeclOrNullptr(NoAliasScopeMD);
+    SrcPtr.adaptPointer(Builder.CreateNoAliasCopyGuard(
+        SrcPtr.getPointer(), NoAliasDecl, Ty.getRestrictIndices(),
+        NoAliasScopeMD));
+  }
+
   // Aggregate assignment turns into llvm.memcpy.  This is almost valid per
   // C99 6.5.16.1p3, which states "If the value being stored in an object is
   // read from another object that overlaps in anyway the storage of the first
   // object, then the overlap shall be exact and the two objects shall have
   // qualified or unqualified versions of a compatible type."
   //
   // memcpy is not defined if the source and destination pointers are exactly
   // equal, but other compilers do this optimization, and almost every memcpy
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

bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
   case Stmt::DefaultStmtClass:  EmitDefaultStmt(cast<DefaultStmt>(*S));   break;
   case Stmt::CaseStmtClass:     EmitCaseStmt(cast<CaseStmt>(*S));         break;
   case Stmt::SEHLeaveStmtClass: EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S)); break;
   }
 
   return true;
 }
 
-bool CodeGenFunction::hasLocalRestrictVars(const CompoundStmt &S) {
+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().isRestrictQualified())
+          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).

clang/lib/CodeGen/CodeGenFunction.h

void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) {
       CGF.DidCallStackSave = OldDidCallStackSave;
       CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize,
                            ValuesToReload);
       PerformCleanup = false;
       CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth;
     }
   };
 
-  // Cleanup stack depth of the RunCleanupsScope that was pushed most recently.
-  EHScopeStack::stable_iterator CurrentCleanupScopeDepth =
-      EHScopeStack::stable_end();
+  // 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);
 
-  bool hasLocalRestrictVars(const CompoundStmt &S);
+  // 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;
void addNoAliasScope(llvm::MDNode *Scope) {
       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, public LexicalNoAliasInfo {
     SourceRange Range;
     SmallVector<const LabelDecl*, 4> Labels;
     LexicalScope *ParentScope;
 
     LexicalScope(const LexicalScope &) = delete;
     void operator=(const LexicalScope &) = delete;
 
private:
   const 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;
+  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);
 
-  void EmitAutoVarNoAlias(const AutoVarEmission &emission);
-
   void EmitStaticVarDecl(const VarDecl &D,
                          llvm::GlobalValue::LinkageTypes Linkage);
 
   class ParamValue {
     llvm::Value *Value;
     unsigned Alignment;
     ParamValue(llvm::Value *V, unsigned A) : Value(V), Alignment(A) {}
   public:

clang/lib/CodeGen/CodeGenFunction.cpp

 }
 
 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
     : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
       Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),
               CGBuilderInserterTy(this)),
       SanOpts(CGM.getLangOpts().Sanitize), DebugInfo(CGM.getModuleDebugInfo()),
       PGO(cgm), ShouldEmitLifetimeMarkers(shouldEmitLifetimeMarkers(
-                    CGM.getCodeGenOpts(), CGM.getLangOpts())),
-      NoAliasDomain(nullptr) {
+                    CGM.getCodeGenOpts(), CGM.getLangOpts())) {
   if (!suppressNewContext)
     CGM.getCXXABI().getMangleContext().startNewFunction();
 
   llvm::FastMathFlags FMF;
   if (CGM.getLangOpts().FastMath)
     FMF.setFast();
   if (CGM.getLangOpts().FiniteMathOnly) {
     FMF.setNoNaNs();
void CodeGenFunction::StartFunction(GlobalDecl GD,
   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 has been blacklisted 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.isInSanitizerBlacklist(SanitizerKind::ID, Fn, Loc))                \
       SanOpts.set(SanitizerKind::ID, false);
#undef SANITIZER
   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)) {
-    // Block-local restrict-qualified pointers have the property of implying
-    // exclusivity of access within their block, even with respect to accesses
-    // in their block prior to the point of declaraction of the
-    // restrict-qualified pointer. We don't want to incur the expense
-    // associated with recording memory-accessing instructions when we won't
-    // have any block-local restrict-qualified pointers, so we check for any
-    // relevant declaractions first.
-    if (hasLocalRestrictVars(*S))
-      FnNoAliasInfo.recordMemoryInsts();
-
     EmitCompoundStmtWithoutScope(*S);
 
     // 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);
   }

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.
 
   if (Args.hasArg(options::OPT_frewrite_map_file) ||
       Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
     for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
                                       options::OPT_frewrite_map_file_EQ)) {
       StringRef Map = A->getValue();
       if (!llvm::sys::fs::exists(Map)) {

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.IndirectTlsSegRefs = Args.hasArg(OPT_mno_tls_direct_seg_refs);
   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
     OPT_fuse_register_sized_bitfield_access);
   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
   Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
   Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
                            Args.hasArg(OPT_new_struct_path_tbaa);
+  if (Arg *FullRestrictArg =
+          Args.getLastArg(OPT_ffull_restrict, OPT_fno_full_restrict)) {
+    Opts.FullRestrict =
+        FullRestrictArg->getOption().matches(OPT_ffull_restrict);
+  }
+  // Keep this behind an option - the alias analysis still works better
+  // with the noalias attribute on arguments.
+  Opts.NoNoAliasArgAttr = Args.hasArg(OPT_fno_noalias_arguments);
   Opts.FineGrainedBitfieldAccesses =
       Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
                    OPT_fno_fine_grained_bitfield_accesses, false);
   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
   Opts.RecordCommandLine = Args.getLastArgValue(OPT_record_command_line);
   Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants);
   Opts.NoCommon = Args.hasArg(OPT_fno_common);
   Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);

clang/test/CodeGen/noalias.c

-// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-optzns %s -emit-llvm -o - | FileCheck %s
-
-int r;
-void ex1(int *);
-
-int *a;
-int *foo() {
-  int * restrict x = a;
-  return x;
-
-// CHECK-LABEL: define i32* @foo()
-// CHECK: [[x_addr_foo1:%[a-z0-9_.]+]] = alloca i32*
-// CHECK: [[x_foo1:%[a-z0-9_.]+]] = load i32*, i32** @a{{.*}}, !noalias [[TAG_foo1:!.*]]
-// CHECK: [[x_a_foo1:%[a-z0-9_.]+]] = call i32* @llvm.noalias.p0i32(i32* [[x_foo1]], metadata [[TAG_foo1]])
-// CHECK: store i32* [[x_a_foo1]], i32** [[x_addr_foo1]]{{.*}}, !noalias [[TAG_foo1]]
-}
-
-int *a2;
-int *foo1(int b) {
-  int * restrict x;
-
-// CHECK-LABEL: define i32* @foo1(i32 %b)
-// CHECK: [[x_addr_foo2:%[a-z0-9_.]+]] = alloca i32*
-// CHECK: [[x2_addr_foo2:%[a-z0-9_.]+]] = alloca i32*
-
-  if (b) {
-    x = a;
-    r += *x;
-    ex1(x);
-
-// CHECK: [[x_foo2:%[a-z0-9_.]+]] = load i32*, i32** @a{{.*}}, !noalias [[x_x2_tag_foo2:!.*]]
-// CHECK: [[x_a_foo2:%[a-z0-9_.]+]] = call i32* @llvm.noalias.p0i32(i32* [[x_foo2]], metadata [[x_tag_foo2:!.*]])
-// CHECK: store i32* [[x_a_foo2]], i32** [[x_addr_foo2]]{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK: call void @ex1
-    ++x;
-    *x = r;
-    ex1(x);
-
-// CHECK:  [[old_x_foo2:%[a-z0-9_.]+]] = load i32*, i32** [[x_addr_foo2]]{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK:  [[x_foo2:%[a-z0-9_.]+]] = getelementptr inbounds i32, i32* [[old_x_foo2]], i32 1
-// CHECK:  [[x_a_foo2:%[a-z0-9_.]+]] = call i32* @llvm.noalias.p0i32(i32* [[x_foo2]], metadata [[x_tag_foo2]])
-// CHECK:  store i32* [[x_a_foo2]], i32** [[x_addr_foo2]]{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK: call void @ex1
-
-    x += b;
-    *x = r;
-    ex1(x);
-
-// CHECK:  [[old_x_foo2:%[a-z0-9_.]+]] = load i32*, i32** [[x_addr_foo2]]{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK:  [[x_foo2:%[a-z0-9_.]+]] = getelementptr inbounds i32, i32* [[old_x_foo2]], i64
-// CHECK:  [[x_a_foo2:%[a-z0-9_.]+]] = call i32* @llvm.noalias.p0i32(i32* [[x_foo2]], metadata [[x_tag_foo2]])
-// CHECK:  store i32* [[x_a_foo2]], i32** [[x_addr_foo2]]{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK: call void @ex1
-
-    int * restrict x2 = a2;
-    *x2 = r;
-    ex1(x2);
-
-// CHECK: [[x2_foo2:%[a-z0-9_.]+]] = load i32*, i32** @a2{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK: [[x2_a_foo2:%[a-z0-9_.]+]] = call i32* @llvm.noalias.p0i32(i32* [[x2_foo2]], metadata [[x2_tag_foo2:!.*]])
-// CHECK: store i32* [[x2_a_foo2]], i32** [[x2_addr_foo2]]{{.*}}, !noalias [[x_x2_tag_foo2]]
-// CHECK: call void @ex1
-  } else {
-    x = a2;
-    r += *x;
-
-// CHECK: [[x_foo2:%[a-z0-9_.]+]] = load i32*, i32** @a2{{.*}}, !noalias [[x_tag_foo2]]
-// CHECK: [[x_a_foo2:%[a-z0-9_.]+]] = call i32* @llvm.noalias.p0i32(i32* [[x_foo2]], metadata [[x_tag_foo2]])
-// CHECK: store i32* [[x_a_foo2]], i32** [[x_addr_foo2]]{{.*}}, !noalias [[x_tag_foo2]]
-  }
-
-  return x;
-}
-
-int *bar() {
-  int * x = a;
-  return x;
-
-// CHECK-LABEL: define i32* @bar()
-// CHECK-NOT: noalias
-// CHECK: ret i32*
-}
-

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
+// XFAIL: *
+
+// 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/side_noalias_reduction_01.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// Check that unnecessary llvm.side.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.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.side.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.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.side.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.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.side.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.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.side.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.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.side.noalias
+
+int *test06(int *p, int n) {
+  int *__restrict rp1;
+  rp1 = p;
+  // llvm.side.noalias rp1 (p)
+
+  {
+    int *__restrict rp;
+    rp = p;
+    // llvm.side.noalias rp (p)
+    // llvm.side.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++;
+    }
+    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.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK:   = tail call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64
+// CHECK-NOT: llvm.side.noalias
+
+// CHECK: declare i32* @llvm.side.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 %agg.result, %struct.FOO* byval(%struct.FOO) align 8 %p) #0 !noalias !21 {
+// CHECK: void @test_FOO_pass(%struct.FOO* noalias sret %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 %agg.result, %struct.FUM* byval(%struct.FUM) align 8 %p) #0 !noalias !41 {
+// CHECK: void @test_FUM_pass(%struct.FUM* noalias sret %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]] = !{i64 -1, i64 0}
+// CHECK: [[TAG_26]] = !{i64 -1, i64 1}
+// CHECK: [[TAG_27]] = !{i64 -1, i64 2}
+
+// CHECK: [[TAG_44]] = !{[[TAG_45:!.*]], [[TAG_46:!.*]], [[TAG_47:!.*]]}
+// CHECK: [[TAG_45]] = !{i64 -1, i64 0, i64 0}
+// CHECK: [[TAG_46]] = !{i64 -1, i64 0, i64 1}
+// CHECK: [[TAG_47]] = !{i64 -1, i64 0, i64 2}

clang/test/CodeGen/restrict/struct_member_01.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -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-apple-darwin -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-apple-darwin -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-apple-darwin -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-apple-darwin -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-apple-darwin -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.side.noalias
+// CHECK-NEXT: @llvm.side.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.side.noalias
+// CHECK-NEXT: @llvm.side.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.side.noalias
+// CHECK-NEXT: @llvm.side.noalias
+// CHECK-NEXT: select
+// CHECK-NEXT: select
+// CHECK-NEXT: @llvm.side.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.side.noalias
+// CHECK-NEXT: load
+// CHECK-NEXT: ret i32

clang/test/CodeGen/restrict/struct_member_07.c

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -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-apple-darwin -O2 -ffull-restrict %s -emit-llvm -o - | FileCheck %s
+
+// 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;
+
+  int *__restrict ptr1;
+  int *__restrict ptr2;
+};
+
+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: 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: 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: 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: ret i32 42
+
+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: ret i32 52
+// 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: ret i32 42

clang/test/OpenMP/taskloop_firstprivate_codegen.cpp

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_MAIN_TY]]* noalias %1)
 
 // CHECK: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_DOUBLE_TY]]*,
 // CHECK: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_DOUBLE_TY]]]*,
 // CHECK: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK: [[PRIV_SIVAR_ADDR:%.+]] = alloca i32*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]], i32** [[PRIV_T_VAR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], i32** [[PRIV_SIVAR_ADDR]])
 
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_DOUBLE_TY]]*, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]],
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_DOUBLE_TY]]]*, [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],

 // CHECK: ret void
 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_TMAIN_TY]]* noalias %1)
 // CHECK: alloca i32*,
 // CHECK-DAG: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK-DAG: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK-DAG: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_INT_TY]]]*,
 // CHECK-DAG: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_INT_TY]]*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, i32** [[PRIV_T_VAR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]], [[S_INT_TY]]** [[PRIV_VAR_ADDR]])
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[PRIV_VAR_ADDR]],
 
 // Privates actually are used.

clang/test/OpenMP/taskloop_lastprivate_codegen.cpp

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_MAIN_TY]]* noalias %1)
 
 // CHECK: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_DOUBLE_TY]]*,
 // CHECK: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_DOUBLE_TY]]]*,
 // CHECK: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK: [[PRIV_SIVAR_ADDR:%.+]] = alloca i32*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]], i32** [[PRIV_T_VAR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], i32** [[PRIV_SIVAR_ADDR]])
 
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_DOUBLE_TY]]*, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]],
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_DOUBLE_TY]]]*, [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],

 // CHECK: ret void
 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_TMAIN_TY]]* noalias %1)
 // CHECK: alloca i32*,
 // CHECK-DAG: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK-DAG: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK-DAG: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_INT_TY]]]*,
 // CHECK-DAG: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_INT_TY]]*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, i32** [[PRIV_T_VAR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]], [[S_INT_TY]]** [[PRIV_VAR_ADDR]])
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[PRIV_VAR_ADDR]],
 
 // Privates actually are used.

clang/test/OpenMP/taskloop_private_codegen.cpp

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_MAIN_TY]]* noalias %1)
 
 // CHECK: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_DOUBLE_TY]]*,
 // CHECK: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_DOUBLE_TY]]]*,
 // CHECK: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK: [[PRIV_SIVAR_ADDR:%.+]] = alloca i32*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]], i32** [[PRIV_T_VAR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], i32** [[PRIV_SIVAR_ADDR]])
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_DOUBLE_TY]]*, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]],
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_DOUBLE_TY]]]*, [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_SIVAR:%.+]] = load i32*, i32** [[PRIV_SIVAR_ADDR]],
 

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_TMAIN_TY]]* noalias %1)
 
 // CHECK: alloca i32*,
 // CHECK-DAG: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK-DAG: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK-DAG: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_INT_TY]]]*,
 // CHECK-DAG: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_INT_TY]]*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, i32** [[PRIV_T_VAR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]], [[S_INT_TY]]** [[PRIV_VAR_ADDR]])
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[PRIV_VAR_ADDR]],
 
 // Privates actually are used.

clang/test/OpenMP/taskloop_simd_firstprivate_codegen.cpp

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_MAIN_TY]]* noalias %1)
 
 // CHECK: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_DOUBLE_TY]]*,
 // CHECK: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_DOUBLE_TY]]]*,
 // CHECK: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK: [[PRIV_SIVAR_ADDR:%.+]] = alloca i32*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]], i32** [[PRIV_T_VAR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], i32** [[PRIV_SIVAR_ADDR]])
 
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_DOUBLE_TY]]*, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]],
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_DOUBLE_TY]]]*, [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],

 // CHECK: ret void
 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_TMAIN_TY]]* noalias %1)
 // CHECK: alloca i32*,
 // CHECK-DAG: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK-DAG: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK-DAG: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_INT_TY]]]*,
 // CHECK-DAG: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_INT_TY]]*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, i32** [[PRIV_T_VAR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]], [[S_INT_TY]]** [[PRIV_VAR_ADDR]])
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[PRIV_VAR_ADDR]],
 
 // Privates actually are used.

clang/test/OpenMP/taskloop_simd_lastprivate_codegen.cpp

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_MAIN_TY]]* noalias %1)
 
 // CHECK: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_DOUBLE_TY]]*,
 // CHECK: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_DOUBLE_TY]]]*,
 // CHECK: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK: [[PRIV_SIVAR_ADDR:%.+]] = alloca i32*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]], i32** [[PRIV_T_VAR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], i32** [[PRIV_SIVAR_ADDR]])
 
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_DOUBLE_TY]]*, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]],
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_DOUBLE_TY]]]*, [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],

 // CHECK: ret void
 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_TMAIN_TY]]* noalias %1)
 // CHECK: alloca i32*,
 // CHECK-DAG: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK-DAG: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK-DAG: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_INT_TY]]]*,
 // CHECK-DAG: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_INT_TY]]*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, i32** [[PRIV_T_VAR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]], [[S_INT_TY]]** [[PRIV_VAR_ADDR]])
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[PRIV_VAR_ADDR]],
 
 // Privates actually are used.

clang/test/OpenMP/taskloop_simd_private_codegen.cpp

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_MAIN_TY]]* noalias %1)
 
 // CHECK: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_DOUBLE_TY]]*,
 // CHECK: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_DOUBLE_TY]]]*,
 // CHECK: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK: [[PRIV_SIVAR_ADDR:%.+]] = alloca i32*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_MAIN_TY]]*, [[S_DOUBLE_TY]]**, i32**, [2 x [[S_DOUBLE_TY]]]**, [2 x i32]**, i32**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]], i32** [[PRIV_T_VAR_ADDR]], [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], i32** [[PRIV_SIVAR_ADDR]])
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_DOUBLE_TY]]*, [[S_DOUBLE_TY]]** [[PRIV_VAR_ADDR]],
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_DOUBLE_TY]]]*, [2 x [[S_DOUBLE_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_SIVAR:%.+]] = load i32*, i32** [[PRIV_SIVAR_ADDR]],
 

 
 // CHECK: define internal i32 [[TASK_ENTRY]](i32 %0, [[KMP_TASK_TMAIN_TY]]* noalias %1)
 
 // CHECK: alloca i32*,
 // CHECK-DAG: [[PRIV_T_VAR_ADDR:%.+]] = alloca i32*,
 // CHECK-DAG: [[PRIV_VEC_ADDR:%.+]] = alloca [2 x i32]*,
 // CHECK-DAG: [[PRIV_S_ARR_ADDR:%.+]] = alloca [2 x [[S_INT_TY]]]*,
 // CHECK-DAG: [[PRIV_VAR_ADDR:%.+]] = alloca [[S_INT_TY]]*,
-// CHECK: [[PRIV_NAFP:%.+]] = call void (i8*, ...)* @llvm.noalias.p0f_isVoidp0i8varargf(void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*),
-// CHECK: store void (i8*, ...)* [[PRIV_NAFP]], void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
+// CHECK: store void (i8*, ...)* bitcast (void ([[PRIVATES_TMAIN_TY]]*, i32**, [2 x i32]**, [2 x [[S_INT_TY]]]**, [[S_INT_TY]]**)* [[PRIVATES_MAP_FN]] to void (i8*, ...)*), void (i8*, ...)** [[MAP_FN_ADDR:%.+]],
 // CHECK: [[MAP_FN:%.+]] = load void (i8*, ...)*, void (i8*, ...)** [[MAP_FN_ADDR]],
 // CHECK: call void (i8*, ...) [[MAP_FN]](i8* %{{.+}}, i32** [[PRIV_T_VAR_ADDR]], [2 x i32]** [[PRIV_VEC_ADDR]], [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]], [[S_INT_TY]]** [[PRIV_VAR_ADDR]])
 // CHECK: [[PRIV_T_VAR:%.+]] = load i32*, i32** [[PRIV_T_VAR_ADDR]],
 // CHECK: [[PRIV_VEC:%.+]] = load [2 x i32]*, [2 x i32]** [[PRIV_VEC_ADDR]],
 // CHECK: [[PRIV_S_ARR:%.+]] = load [2 x [[S_INT_TY]]]*, [2 x [[S_INT_TY]]]** [[PRIV_S_ARR_ADDR]],
 // CHECK: [[PRIV_VAR:%.+]] = load [[S_INT_TY]]*, [[S_INT_TY]]** [[PRIV_VAR_ADDR]],
 
 // Privates actually are used.

llvm/lib/IR/IRBuilder.cpp

return CreateGenericNoAliasIntrinsic(
       {llvm::MDNode::get(Context, IndicesArray), ScopeTag}, {}, Name);
 }
 
 Instruction *IRBuilderBase::CreateGenericNoAliasIntrinsic(
     Intrinsic::ID ID, Value *Ptr, ArrayRef<Value *> args_opt,
     ArrayRef<MDNode *> MDNodes, ArrayRef<Value *> MDValues, const Twine &Name) {
   // FIXME: We can currently mangle just about everything, but not literal
   // structs (for those, bitcast to i8*).
-  //@ JDO: FIXME: as far as I see in 'getMangledTypeStr', this should be ok now.
+  // FIXME: as far as I see in 'getMangledTypeStr', this should be ok now.
   Value *CPtr = Ptr;
   if (auto *STyp =
         dyn_cast<StructType>(CPtr->getType()->getPointerElementType())) {
     if (STyp->isLiteral())
       CPtr = getCastedInt8PtrValue(CPtr);
   }
 
   SmallVector<Type *, 7> Types = {CPtr->getType()};