Allow specifying AA info when constructing certain libcalls

[yuyichao]

Summary

And maintain such info when simplifying libcalls. These info are already usable by TBAA.

[nikic]

Tests?

[yuyichao]

I'm currently running the existing tests to find regressions... I'll probably just add tbaa to most/all of the existing tests and it'll probably take a while...

[yuyichao]

Propagate alias info to load and store instructions in additional to function calls.

Update formatting and add/update tests.

[efriedma]

I guess this can't hurt, but how do you expect libcalls to acquire TBAA info in the first place? I don't think clang will generate it.

[yuyichao]

Other frontends could. I'm adding this because TBAA can already use this but right now if the frontend emits them, it can still be stripped out by instcombine.

[yuyichao]

Any review?

[sdesmalen]

Seems like a fair change to me when this TBAA information is available.

[yuyichao]

Rebased to fix test conflict. Tests passed locally.

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

namespace llvm {
 
   /// Return V if it is an i8*, otherwise cast it to i8*.
   Value *castToCStr(Value *V, IRBuilderBase &B);
 
   /// Emit a call to the strlen function to the builder, for the specified
   /// pointer. Ptr is required to be some pointer type, and the return value has
   /// 'intptr_t' type.
   Value *emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
-                    const TargetLibraryInfo *TLI);
+                    const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strdup function to the builder, for the specified
   /// pointer. Ptr is required to be some pointer type, and the return value has
   /// 'i8*' type.
-  Value *emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI);
+  Value *emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                    const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strnlen function to the builder, for the specified
   /// pointer. Ptr is required to be some pointer type, MaxLen must be of size_t
   /// type, and the return value has 'intptr_t' type.
   Value *emitStrNLen(Value *Ptr, Value *MaxLen, IRBuilderBase &B,
-                     const DataLayout &DL, const TargetLibraryInfo *TLI);
+                     const DataLayout &DL, const TargetLibraryInfo *TLI,
+                     const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strchr function to the builder, for the specified
   /// pointer and character. Ptr is required to be some pointer type, and the
   /// return value has 'i8*' type.
   Value *emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
-                    const TargetLibraryInfo *TLI);
+                    const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strncmp function to the builder.
   Value *emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
-                     const DataLayout &DL, const TargetLibraryInfo *TLI);
+                     const DataLayout &DL, const TargetLibraryInfo *TLI,
+                     const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strcpy function to the builder, for the specified
   /// pointer arguments.
   Value *emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
-                    const TargetLibraryInfo *TLI);
+                    const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the stpcpy function to the builder, for the specified
   /// pointer arguments.
   Value *emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
-                    const TargetLibraryInfo *TLI);
+                    const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strncpy function to the builder, for the specified
   /// pointer arguments and length.
   Value *emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
-                     const TargetLibraryInfo *TLI);
+                     const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the stpncpy function to the builder, for the specified
   /// pointer arguments and length.
   Value *emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
-                     const TargetLibraryInfo *TLI);
+                     const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the __memcpy_chk function to the builder. This expects that
   /// the Len and ObjSize have type 'intptr_t' and Dst/Src are pointers.
   Value *emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
                        IRBuilderBase &B, const DataLayout &DL,
-                       const TargetLibraryInfo *TLI);
+                       const TargetLibraryInfo *TLI,
+                       const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the memchr function. This assumes that Ptr is a pointer,
   /// Val is an i32 value, and Len is an 'intptr_t' value.
   Value *emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
-                    const DataLayout &DL, const TargetLibraryInfo *TLI);
+                    const DataLayout &DL, const TargetLibraryInfo *TLI,
+                    const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the memcmp function.
   Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
-                    const DataLayout &DL, const TargetLibraryInfo *TLI);
+                    const DataLayout &DL, const TargetLibraryInfo *TLI,
+                    const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the bcmp function.
   Value *emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
-                  const DataLayout &DL, const TargetLibraryInfo *TLI);
+                  const DataLayout &DL, const TargetLibraryInfo *TLI,
+                  const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the memccpy function.
   Value *emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
-                     IRBuilderBase &B, const TargetLibraryInfo *TLI);
+                     IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                     const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the snprintf function.
   Value *emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
                       ArrayRef<Value *> Args, IRBuilderBase &B,
-                      const TargetLibraryInfo *TLI);
+                      const TargetLibraryInfo *TLI,
+                      const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the sprintf function.
   Value *emitSPrintf(Value *Dest, Value *Fmt, ArrayRef<Value *> VariadicArgs,
-                     IRBuilderBase &B, const TargetLibraryInfo *TLI);
+                     IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                     const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strcat function.
   Value *emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
-                    const TargetLibraryInfo *TLI);
+                    const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strlcpy function.
   Value *emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
-                     const TargetLibraryInfo *TLI);
+                     const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strlcat function.
   Value *emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
-                     const TargetLibraryInfo *TLI);
+                     const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the strncat function.
   Value *emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
-                     const TargetLibraryInfo *TLI);
+                     const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the vsnprintf function.
   Value *emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
-                       IRBuilderBase &B, const TargetLibraryInfo *TLI);
+                       IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                       const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the vsprintf function.
   Value *emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilderBase &B,
-                      const TargetLibraryInfo *TLI);
+                      const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo = AAMDNodes());
 
   /// Emit a call to the unary function named 'Name' (e.g.  'floor'). This
   /// function is known to take a single of type matching 'Op' and returns one
   /// value with the same type. If 'Op' is a long double, 'l' is added as the
   /// suffix of name, if 'Op' is a float, we add a 'f' suffix.
   Value *emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
                               const AttributeList &Attrs);
 

llvm/include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
   Value *optimizeSnPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFWrite(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFPuts(CallInst *CI, IRBuilderBase &B);
   Value *optimizePuts(CallInst *CI, IRBuilderBase &B);
 
   // Helper methods
   Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
-                          IRBuilderBase &B);
+                          IRBuilderBase &B, const AAMDNodes &AATags);
   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
                       SmallVectorImpl<CallInst *> &SinCalls,
                       SmallVectorImpl<CallInst *> &CosCalls,
                       SmallVectorImpl<CallInst *> &SinCosCalls);
   Value *optimizePrintFString(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSPrintFString(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSnPrintFString(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFPrintFString(CallInst *CI, IRBuilderBase &B);

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
   unsigned AS = V->getType()->getPointerAddressSpace();
   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
 }
 
 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
                           ArrayRef<Type *> ParamTypes,
                           ArrayRef<Value *> Operands, IRBuilderBase &B,
                           const TargetLibraryInfo *TLI,
-                          bool IsVaArgs = false) {
+                          bool IsVaArgs = false, const AAMDNodes &AAInfo = AAMDNodes()) {
   if (!TLI->has(TheLibFunc))
     return nullptr;
 
   Module *M = B.GetInsertBlock()->getModule();
   StringRef FuncName = TLI->getName(TheLibFunc);
   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
   FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
   inferLibFuncAttributes(M, FuncName, *TLI);
   CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
   if (const Function *F =
           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
     CI->setCallingConv(F->getCallingConv());
+  CI->setAAMetadata(AAInfo);
   return CI;
 }
 
 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
-                        const TargetLibraryInfo *TLI) {
+                        const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
-                     B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
+                     B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
-                        const TargetLibraryInfo *TLI) {
+                        const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
-                     castToCStr(Ptr, B), B, TLI);
+                     castToCStr(Ptr, B), B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
-                        const TargetLibraryInfo *TLI) {
+                        const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   Type *I8Ptr = B.getInt8PtrTy();
   Type *I32Ty = B.getInt32Ty();
   return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
-                     {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
+                     {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
-                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
+                         const DataLayout &DL, const TargetLibraryInfo *TLI,
+                         const AAMDNodes &AAInfo) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(
       LibFunc_strncmp, B.getInt32Ty(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
-      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
+      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
-                        const TargetLibraryInfo *TLI) {
+                        const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   Type *I8Ptr = B.getInt8PtrTy();
   return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
-                     {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
+                     {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
-                        const TargetLibraryInfo *TLI) {
+                        const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   Type *I8Ptr = B.getInt8PtrTy();
   return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
-                     {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
+                     {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
-                         const TargetLibraryInfo *TLI) {
+                         const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   Type *I8Ptr = B.getInt8PtrTy();
   return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
-                     {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
+                     {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
-                         const TargetLibraryInfo *TLI) {
+                         const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   Type *I8Ptr = B.getInt8PtrTy();
   return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
-                     {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
+                     {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
                            IRBuilderBase &B, const DataLayout &DL,
-                           const TargetLibraryInfo *TLI) {
+                           const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   if (!TLI->has(LibFunc_memcpy_chk))
     return nullptr;
 
   Module *M = B.GetInsertBlock()->getModule();
   AttributeList AS;
   AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
                           Attribute::NoUnwind);
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   FunctionCallee MemCpy = M->getOrInsertFunction(
       "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
       B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
       DL.getIntPtrType(Context));
   Dst = castToCStr(Dst, B);
   Src = castToCStr(Src, B);
   CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
   if (const Function *F =
           dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
     CI->setCallingConv(F->getCallingConv());
+  CI->setAAMetadata(AAInfo);
   return CI;
 }
 
 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
-                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
+                        const DataLayout &DL, const TargetLibraryInfo *TLI,
+                        const AAMDNodes &AAInfo) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(
       LibFunc_memchr, B.getInt8PtrTy(),
       {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
-      {castToCStr(Ptr, B), Val, Len}, B, TLI);
+      {castToCStr(Ptr, B), Val, Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
-                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
+                        const DataLayout &DL, const TargetLibraryInfo *TLI,
+                        const AAMDNodes &AAInfo) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(
       LibFunc_memcmp, B.getInt32Ty(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
-      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
+      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
-                      const DataLayout &DL, const TargetLibraryInfo *TLI) {
+                      const DataLayout &DL, const TargetLibraryInfo *TLI,
+                      const AAMDNodes &AAInfo) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(
       LibFunc_bcmp, B.getInt32Ty(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
-      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
+      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
-                         IRBuilderBase &B, const TargetLibraryInfo *TLI) {
+                         IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                         const AAMDNodes &AAInfo) {
   return emitLibCall(
       LibFunc_memccpy, B.getInt8PtrTy(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
-      {Ptr1, Ptr2, Val, Len}, B, TLI);
+      {Ptr1, Ptr2, Val, Len}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
                           ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
-                          const TargetLibraryInfo *TLI) {
+                          const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
   Args.insert(Args.end(), VariadicArgs.begin(), VariadicArgs.end());
   return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
                      {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
-                     Args, B, TLI, /*IsVaArgs=*/true);
+                     Args, B, TLI, /*IsVaArgs=*/true, AAInfo);
 }
 
 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
                          ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
-                         const TargetLibraryInfo *TLI) {
+                         const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
   Args.insert(Args.end(), VariadicArgs.begin(), VariadicArgs.end());
   return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
                      {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
-                     /*IsVaArgs=*/true);
+                     /*IsVaArgs=*/true, AAInfo);
 }
 
 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
-                        const TargetLibraryInfo *TLI) {
+                        const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
                      {B.getInt8PtrTy(), B.getInt8PtrTy()},
-                     {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
+                     {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
-                         const TargetLibraryInfo *TLI) {
+                         const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   return emitLibCall(LibFunc_strlcpy, Size->getType(),
                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
-                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
+                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
-                         const TargetLibraryInfo *TLI) {
+                         const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   return emitLibCall(LibFunc_strlcat, Size->getType(),
                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
-                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
+                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
-                         const TargetLibraryInfo *TLI) {
+                         const TargetLibraryInfo *TLI, const AAMDNodes &AAInfo) {
   return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
                      {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
-                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
+                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
-                           IRBuilderBase &B, const TargetLibraryInfo *TLI) {
+                           IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                           const AAMDNodes &AAInfo) {
   return emitLibCall(
       LibFunc_vsnprintf, B.getInt32Ty(),
       {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
-      {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
+      {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI, false, AAInfo);
 }
 
 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
-                          IRBuilderBase &B, const TargetLibraryInfo *TLI) {
+                          IRBuilderBase &B, const TargetLibraryInfo *TLI,
+                          const AAMDNodes &AAInfo) {
   return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
                      {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
-                     {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
+                     {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI, false, AAInfo);
 }
 
 /// Append a suffix to the function name according to the type of 'Op'.
 static void appendTypeSuffix(Value *Op, StringRef &Name,
                              SmallString<20> &NameBuffer) {
   if (!Op->getType()->isDoubleTy()) {
       NameBuffer += Name;
 

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilderBase &B) {
   else
     return nullptr;
   --Len; // Unbias length.
 
   // Handle the simple, do-nothing case: strcat(x, "") -> x
   if (Len == 0)
     return Dst;
 
-  return emitStrLenMemCpy(Src, Dst, Len, B);
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
+  return emitStrLenMemCpy(Src, Dst, Len, B, AATags);
 }
 
 Value *LibCallSimplifier::emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
-                                           IRBuilderBase &B) {
+                                           IRBuilderBase &B, const AAMDNodes &AATags) {
   // We need to find the end of the destination string.  That's where the
   // memory is to be moved to. We just generate a call to strlen.
-  Value *DstLen = emitStrLen(Dst, B, DL, TLI);
+  Value *DstLen = emitStrLen(Dst, B, DL, TLI, AATags);
   if (!DstLen)
     return nullptr;
 
   // Now that we have the destination's length, we must index into the
   // destination's pointer to get the actual memcpy destination (end of
   // the string .. we're concatenating).
   Value *CpyDst = B.CreateGEP(B.getInt8Ty(), Dst, DstLen, "endptr");
 
   // We have enough information to now generate the memcpy call to do the
   // concatenation for us.  Make a memcpy to copy the nul byte with align = 1.
   B.CreateMemCpy(
       CpyDst, Align(1), Src, Align(1),
-      ConstantInt::get(DL.getIntPtrType(Src->getContext()), Len + 1));
+      ConstantInt::get(DL.getIntPtrType(Src->getContext()), Len + 1),
+      false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
   return Dst;
 }
 
 Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilderBase &B) {
   // Extract some information from the instruction.
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
   Value *Size = CI->getArgOperand(2);
Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilderBase &B) {
   // strncat(x, "", c) -> x
   if (SrcLen == 0)
     return Dst;
 
   // We don't optimize this case.
   if (Len < SrcLen)
     return nullptr;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // strncat(x, s, c) -> strcat(x, s)
   // s is constant so the strcat can be optimized further.
-  return emitStrLenMemCpy(Src, Dst, SrcLen, B);
+  return emitStrLenMemCpy(Src, Dst, SrcLen, B, AATags);
 }
 
 Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilderBase &B) {
   Function *Callee = CI->getCalledFunction();
   FunctionType *FT = Callee->getFunctionType();
   Value *SrcStr = CI->getArgOperand(0);
   annotateNonNullBasedOnAccess(CI, 0);
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
+
   // If the second operand is non-constant, see if we can compute the length
   // of the input string and turn this into memchr.
   ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
   if (!CharC) {
     uint64_t Len = GetStringLength(SrcStr);
     if (Len)
       annotateDereferenceableBytes(CI, 0, Len);
     else
       return nullptr;
     if (!FT->getParamType(1)->isIntegerTy(32)) // memchr needs i32.
       return nullptr;
 
     return emitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
                       ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len),
-                      B, DL, TLI);
+                      B, DL, TLI, AATags);
   }
 
   // Otherwise, the character is a constant, see if the first argument is
   // a string literal.  If so, we can constant fold.
   StringRef Str;
   if (!getConstantStringInfo(SrcStr, Str)) {
     if (CharC->isZero()) // strchr(p, 0) -> p + strlen(p)
-      if (Value *StrLen = emitStrLen(SrcStr, B, DL, TLI))
+      if (Value *StrLen = emitStrLen(SrcStr, B, DL, TLI, AATags))
         return B.CreateGEP(B.getInt8Ty(), SrcStr, StrLen, "strchr");
     return nullptr;
   }
 
   // Compute the offset, make sure to handle the case when we're searching for
   // zero (a weird way to spell strlen).
   size_t I = (0xFF & CharC->getSExtValue()) == 0
                  ? Str.size()
Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilderBase &B) {
 
   // Cannot fold anything if we're not looking for a constant.
   if (!CharC)
     return nullptr;
 
   StringRef Str;
   if (!getConstantStringInfo(SrcStr, Str)) {
     // strrchr(s, 0) -> strchr(s, 0)
-    if (CharC->isZero())
-      return emitStrChr(SrcStr, '\0', B, TLI);
+    if (CharC->isZero()) {
+      AAMDNodes AATags;
+      CI->getAAMetadata(AATags);
+      return emitStrChr(SrcStr, '\0', B, TLI, AATags);
+    }
     return nullptr;
   }
 
   // Compute the offset.
   size_t I = (0xFF & CharC->getSExtValue()) == 0
                  ? Str.size()
                  : Str.rfind(CharC->getSExtValue());
   if (I == StringRef::npos) // Didn't find the char. Return null.
Value *LibCallSimplifier::optimizeStrCmp(CallInst *CI, IRBuilderBase &B) {
   // strcmp(P, "x") -> memcmp(P, "x", 2)
   uint64_t Len1 = GetStringLength(Str1P);
   if (Len1)
     annotateDereferenceableBytes(CI, 0, Len1);
   uint64_t Len2 = GetStringLength(Str2P);
   if (Len2)
     annotateDereferenceableBytes(CI, 1, Len2);
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   if (Len1 && Len2) {
     return emitMemCmp(Str1P, Str2P,
                       ConstantInt::get(DL.getIntPtrType(CI->getContext()),
                                        std::min(Len1, Len2)),
-                      B, DL, TLI);
+                      B, DL, TLI, AATags);
   }
 
   // strcmp to memcmp
   if (!HasStr1 && HasStr2) {
     if (canTransformToMemCmp(CI, Str1P, Len2, DL))
       return emitMemCmp(
           Str1P, Str2P,
           ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len2), B, DL,
-          TLI);
+          TLI, AATags);
   } else if (HasStr1 && !HasStr2) {
     if (canTransformToMemCmp(CI, Str2P, Len1, DL))
       return emitMemCmp(
           Str1P, Str2P,
           ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len1), B, DL,
-          TLI);
+          TLI, AATags);
   }
 
   annotateNonNullBasedOnAccess(CI, {0, 1});
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilderBase &B) {
   Value *Str1P = CI->getArgOperand(0);
Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilderBase &B) {
   if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
     Length = LengthArg->getZExtValue();
   else
     return nullptr;
 
   if (Length == 0) // strncmp(x,y,0)   -> 0
     return ConstantInt::get(CI->getType(), 0);
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   if (Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1)
-    return emitMemCmp(Str1P, Str2P, Size, B, DL, TLI);
+    return emitMemCmp(Str1P, Str2P, Size, B, DL, TLI, AATags);
 
   StringRef Str1, Str2;
   bool HasStr1 = getConstantStringInfo(Str1P, Str1);
   bool HasStr2 = getConstantStringInfo(Str2P, Str2);
 
   // strncmp(x, y)  -> cnst  (if both x and y are constant strings)
   if (HasStr1 && HasStr2) {
     StringRef SubStr1 = Str1.substr(0, Length);
Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilderBase &B) {
 
   // strncmp to memcmp
   if (!HasStr1 && HasStr2) {
     Len2 = std::min(Len2, Length);
     if (canTransformToMemCmp(CI, Str1P, Len2, DL))
       return emitMemCmp(
           Str1P, Str2P,
           ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len2), B, DL,
-          TLI);
+          TLI, AATags);
   } else if (HasStr1 && !HasStr2) {
     Len1 = std::min(Len1, Length);
     if (canTransformToMemCmp(CI, Str2P, Len1, DL))
       return emitMemCmp(
           Str1P, Str2P,
           ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len1), B, DL,
-          TLI);
+          TLI, AATags);
   }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrNDup(CallInst *CI, IRBuilderBase &B) {
   Value *Src = CI->getArgOperand(0);
   ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
   uint64_t SrcLen = GetStringLength(Src);
   if (SrcLen && Size) {
     annotateDereferenceableBytes(CI, 0, SrcLen);
-    if (SrcLen <= Size->getZExtValue() + 1)
-      return emitStrDup(Src, B, TLI);
+    if (SrcLen <= Size->getZExtValue() + 1) {
+      AAMDNodes AATags;
+      CI->getAAMetadata(AATags);
+      return emitStrDup(Src, B, TLI, AATags);
+    }
   }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
   if (Dst == Src) // strcpy(x,x)  -> x
     return Src;
   
   annotateNonNullBasedOnAccess(CI, {0, 1});
   // See if we can get the length of the input string.
   uint64_t Len = GetStringLength(Src);
   if (Len)
     annotateDereferenceableBytes(CI, 1, Len);
   else
     return nullptr;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // We have enough information to now generate the memcpy call to do the
   // copy for us.  Make a memcpy to copy the nul byte with align = 1.
   CallInst *NewCI =
       B.CreateMemCpy(Dst, Align(1), Src, Align(1),
-                     ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len));
+                     ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len),
+                     false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return Dst;
 }
 
 Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
   Function *Callee = CI->getCalledFunction();
   Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   if (Dst == Src) { // stpcpy(x,x)  -> x+strlen(x)
-    Value *StrLen = emitStrLen(Src, B, DL, TLI);
+    Value *StrLen = emitStrLen(Src, B, DL, TLI, AATags);
     return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
   }
 
   // See if we can get the length of the input string.
   uint64_t Len = GetStringLength(Src);
   if (Len)
     annotateDereferenceableBytes(CI, 1, Len);
   else
     return nullptr;
 
   Type *PT = Callee->getFunctionType()->getParamType(0);
   Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
   Value *DstEnd = B.CreateGEP(B.getInt8Ty(), Dst,
                               ConstantInt::get(DL.getIntPtrType(PT), Len - 1));
 
   // We have enough information to now generate the memcpy call to do the
   // copy for us.  Make a memcpy to copy the nul byte with align = 1.
-  CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), LenV);
+  CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), LenV,
+      false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return DstEnd;
 }
 
 Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) {
   Function *Callee = CI->getCalledFunction();
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) {
   uint64_t SrcLen = GetStringLength(Src);
   if (SrcLen) {
     annotateDereferenceableBytes(CI, 1, SrcLen);
     --SrcLen; // Unbias length.
   } else {
     return nullptr;
   }
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   if (SrcLen == 0) {
     // strncpy(x, "", y) -> memset(align 1 x, '\0', y)
-    CallInst *NewCI = B.CreateMemSet(Dst, B.getInt8('\0'), Size, Align(1));
+    CallInst *NewCI = B.CreateMemSet(Dst, B.getInt8('\0'), Size, Align(1),
+                                     false, AATags.TBAA, AATags.Scope, AATags.NoAlias);
     AttrBuilder ArgAttrs(CI->getAttributes().getParamAttributes(0));
     NewCI->setAttributes(NewCI->getAttributes().addParamAttributes(
         CI->getContext(), 0, ArgAttrs));
     return Dst;
   }
 
   // strncpy(a, "a", 4) - > memcpy(a, "a\0\0\0", 4)
   if (Len > SrcLen + 1) {
     if (Len <= 128) {
       StringRef Str;
       if (!getConstantStringInfo(Src, Str))
         return nullptr;
       std::string SrcStr = Str.str();
       SrcStr.resize(Len, '\0');
       Src = B.CreateGlobalString(SrcStr, "str");
     } else {
       return nullptr;
     }
   }
 
   Type *PT = Callee->getFunctionType()->getParamType(0);
   // strncpy(x, s, c) -> memcpy(align 1 x, align 1 s, c) [s and c are constant]
   CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1),
-                                   ConstantInt::get(DL.getIntPtrType(PT), Len));
+                                   ConstantInt::get(DL.getIntPtrType(PT), Len),
+                                   false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return Dst;
 }
 
 Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B,
                                                unsigned CharSize) {
   Value *Src = CI->getArgOperand(0);
 
if (HasS1 && HasS2) {
     if (I == StringRef::npos) // No match.
       return Constant::getNullValue(CI->getType());
 
     return B.CreateGEP(B.getInt8Ty(), CI->getArgOperand(0), B.getInt64(I),
                        "strpbrk");
   }
 
   // strpbrk(s, "a") -> strchr(s, 'a')
-  if (HasS2 && S2.size() == 1)
-    return emitStrChr(CI->getArgOperand(0), S2[0], B, TLI);
+  if (HasS2 && S2.size() == 1) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
+    return emitStrChr(CI->getArgOperand(0), S2[0], B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrTo(CallInst *CI, IRBuilderBase &B) {
   Value *EndPtr = CI->getArgOperand(1);
   if (isa<ConstantPointerNull>(EndPtr)) {
     // With a null EndPtr, this function won't capture the main argument.
Value *LibCallSimplifier::optimizeStrCSpn(CallInst *CI, IRBuilderBase &B) {
   if (HasS1 && HasS2) {
     size_t Pos = S1.find_first_of(S2);
     if (Pos == StringRef::npos)
       Pos = S1.size();
     return ConstantInt::get(CI->getType(), Pos);
   }
 
   // strcspn(s, "") -> strlen(s)
-  if (HasS2 && S2.empty())
-    return emitStrLen(CI->getArgOperand(0), B, DL, TLI);
+  if (HasS2 && S2.empty()) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
+    return emitStrLen(CI->getArgOperand(0), B, DL, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrStr(CallInst *CI, IRBuilderBase &B) {
   // fold strstr(x, x) -> x.
   if (CI->getArgOperand(0) == CI->getArgOperand(1))
     return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0
   if (isOnlyUsedInEqualityComparison(CI, CI->getArgOperand(0))) {
-    Value *StrLen = emitStrLen(CI->getArgOperand(1), B, DL, TLI);
+    Value *StrLen = emitStrLen(CI->getArgOperand(1), B, DL, TLI, AATags);
     if (!StrLen)
       return nullptr;
     Value *StrNCmp = emitStrNCmp(CI->getArgOperand(0), CI->getArgOperand(1),
-                                 StrLen, B, DL, TLI);
+                                 StrLen, B, DL, TLI, AATags);
     if (!StrNCmp)
       return nullptr;
     for (auto UI = CI->user_begin(), UE = CI->user_end(); UI != UE;) {
       ICmpInst *Old = cast<ICmpInst>(*UI++);
       Value *Cmp =
           B.CreateICmp(Old->getPredicate(), StrNCmp,
                        ConstantInt::getNullValue(StrNCmp->getType()), "cmp");
       replaceAllUsesWith(Old, Cmp);
if (HasStr1 && HasStr2) {
     Value *Result = castToCStr(CI->getArgOperand(0), B);
     Result =
         B.CreateConstInBoundsGEP1_64(B.getInt8Ty(), Result, Offset, "strstr");
     return B.CreateBitCast(Result, CI->getType());
   }
 
   // fold strstr(x, "y") -> strchr(x, 'y').
   if (HasStr2 && ToFindStr.size() == 1) {
-    Value *StrChr = emitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TLI);
+    Value *StrChr = emitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TLI, AATags);
     return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr;
   }
 
   annotateNonNullBasedOnAccess(CI, {0, 1});
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilderBase &B) {
Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilderBase &B) {
 
   // memcmp(x, y, Len) == 0 -> bcmp(x, y, Len) == 0
   // bcmp can be more efficient than memcmp because it only has to know that
   // there is a difference, not how different one is to the other.
   if (TLI->has(LibFunc_bcmp) && isOnlyUsedInZeroEqualityComparison(CI)) {
     Value *LHS = CI->getArgOperand(0);
     Value *RHS = CI->getArgOperand(1);
     Value *Size = CI->getArgOperand(2);
-    return emitBCmp(LHS, RHS, Size, B, DL, TLI);
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
+    return emitBCmp(LHS, RHS, Size, B, DL, TLI, AATags);
   }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeBCmp(CallInst *CI, IRBuilderBase &B) {
   return optimizeMemCmpBCmpCommon(CI, B);
 }
 
 Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Size = CI->getArgOperand(2);
   annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
   if (isa<IntrinsicInst>(CI))
     return nullptr;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // memcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n)
   CallInst *NewCI = B.CreateMemCpy(CI->getArgOperand(0), Align(1),
-                                   CI->getArgOperand(1), Align(1), Size);
+                                   CI->getArgOperand(1), Align(1), Size,
+                                   false, AATags.TBAA, AATags.TBAAStruct,
+                                   AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return CI->getArgOperand(0);
 }
 
 Value *LibCallSimplifier::optimizeMemCCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
   ConstantInt *StopChar = dyn_cast<ConstantInt>(CI->getArgOperand(2));
   ConstantInt *N = dyn_cast<ConstantInt>(CI->getArgOperand(3));
   StringRef SrcStr;
   if (CI->use_empty() && Dst == Src)
     return Dst;
   // memccpy(d, s, c, 0) -> nullptr
   if (N) {
     if (N->isNullValue())
       return Constant::getNullValue(CI->getType());
     if (!getConstantStringInfo(Src, SrcStr, /*Offset=*/0,
                                /*TrimAtNul=*/false) ||
         !StopChar)
       return nullptr;
   } else {
     return nullptr;
   }
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
+
   // Wrap arg 'c' of type int to char
   size_t Pos = SrcStr.find(StopChar->getSExtValue() & 0xFF);
   if (Pos == StringRef::npos) {
     if (N->getZExtValue() <= SrcStr.size()) {
-      B.CreateMemCpy(Dst, Align(1), Src, Align(1), CI->getArgOperand(3));
+      B.CreateMemCpy(Dst, Align(1), Src, Align(1), CI->getArgOperand(3),
+                     false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
       return Constant::getNullValue(CI->getType());
     }
     return nullptr;
   }
 
   Value *NewN =
       ConstantInt::get(N->getType(), std::min(uint64_t(Pos + 1), N->getZExtValue()));
   // memccpy -> llvm.memcpy
-  B.CreateMemCpy(Dst, Align(1), Src, Align(1), NewN);
+  B.CreateMemCpy(Dst, Align(1), Src, Align(1), NewN,
+                 false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
   return Pos + 1 <= N->getZExtValue()
              ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, NewN)
              : Constant::getNullValue(CI->getType());
 }
 
 Value *LibCallSimplifier::optimizeMemPCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Dst = CI->getArgOperand(0);
   Value *N = CI->getArgOperand(2);
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // mempcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n), x + n
   CallInst *NewCI =
-      B.CreateMemCpy(Dst, Align(1), CI->getArgOperand(1), Align(1), N);
+      B.CreateMemCpy(Dst, Align(1), CI->getArgOperand(1), Align(1), N,
+                     false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return B.CreateInBoundsGEP(B.getInt8Ty(), Dst, N);
 }
 
 Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilderBase &B) {
   Value *Size = CI->getArgOperand(2);
   annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
   if (isa<IntrinsicInst>(CI))
     return nullptr;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // memmove(x, y, n) -> llvm.memmove(align 1 x, align 1 y, n)
   CallInst *NewCI = B.CreateMemMove(CI->getArgOperand(0), Align(1),
-                                    CI->getArgOperand(1), Align(1), Size);
+                                    CI->getArgOperand(1), Align(1), Size,
+                                    false, AATags.TBAA, AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return CI->getArgOperand(0);
 }
 
 /// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n).
 Value *LibCallSimplifier::foldMallocMemset(CallInst *Memset, IRBuilderBase &B) {
   // This has to be a memset of zeros (bzero).
   auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) {
   Value *Size = CI->getArgOperand(2);
   annotateNonNullAndDereferenceable(CI, 0, Size, DL);
   if (isa<IntrinsicInst>(CI))
     return nullptr;
 
   if (auto *Calloc = foldMallocMemset(CI, B))
     return Calloc;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // memset(p, v, n) -> llvm.memset(align 1 p, v, n)
   Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
-  CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1));
+  CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1),
+                                   false, AATags.TBAA, AATags.Scope, AATags.NoAlias);
   NewCI->setAttributes(CI->getAttributes());
   return CI->getArgOperand(0);
 }
 
 Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) {
   if (isa<ConstantPointerNull>(CI->getArgOperand(0)))
     return emitMalloc(CI->getArgOperand(1), B, DL, TLI);
 

 
 Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI,
                                                 IRBuilderBase &B) {
   // Check for a fixed format string.
   StringRef FormatStr;
   if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
     return nullptr;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // If we just have a format string (nothing else crazy) transform it.
   if (CI->getNumArgOperands() == 2) {
     // Make sure there's no % in the constant array.  We could try to handle
     // %% -> % in the future if we cared.
     if (FormatStr.find('%') != StringRef::npos)
       return nullptr; // we found a format specifier, bail out.
 
     // sprintf(str, fmt) -> llvm.memcpy(align 1 str, align 1 fmt, strlen(fmt)+1)
     B.CreateMemCpy(
         CI->getArgOperand(0), Align(1), CI->getArgOperand(1), Align(1),
         ConstantInt::get(DL.getIntPtrType(CI->getContext()),
-                         FormatStr.size() + 1)); // Copy the null byte.
+                         FormatStr.size() + 1), // Copy the null byte.
+        false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
     return ConstantInt::get(CI->getType(), FormatStr.size());
   }
 
   // The remaining optimizations require the format string to be "%s" or "%c"
   // and have an extra operand.
   if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
       CI->getNumArgOperands() < 3)
     return nullptr;
Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI,
   if (FormatStr[1] == 's') {
     // sprintf(dest, "%s", str) -> llvm.memcpy(align 1 dest, align 1 str,
     // strlen(str)+1)
     if (!CI->getArgOperand(2)->getType()->isPointerTy())
       return nullptr;
 
     if (CI->use_empty())
       // sprintf(dest, "%s", str) -> strcpy(dest, str)
-      return emitStrCpy(CI->getArgOperand(0), CI->getArgOperand(2), B, TLI);
+      return emitStrCpy(CI->getArgOperand(0), CI->getArgOperand(2), B, TLI, AATags);
 
     uint64_t SrcLen = GetStringLength(CI->getArgOperand(2));
     if (SrcLen) {
       B.CreateMemCpy(
           CI->getArgOperand(0), Align(1), CI->getArgOperand(2), Align(1),
-          ConstantInt::get(DL.getIntPtrType(CI->getContext()), SrcLen));
+          ConstantInt::get(DL.getIntPtrType(CI->getContext()), SrcLen),
+          false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
       // Returns total number of characters written without null-character.
       return ConstantInt::get(CI->getType(), SrcLen - 1);
     } else if (Value *V = emitStpCpy(CI->getArgOperand(0), CI->getArgOperand(2),
-                                     B, TLI)) {
+                                     B, TLI, AATags)) {
       // sprintf(dest, "%s", str) -> stpcpy(dest, str) - dest
       Value *PtrDiff = B.CreatePtrDiff(V, CI->getArgOperand(0));
       return B.CreateIntCast(PtrDiff, CI->getType(), false);
     }
 
     bool OptForSize = CI->getFunction()->hasOptSize() ||
                       llvm::shouldOptimizeForSize(CI->getParent(), PSI, BFI,
                                                   PGSOQueryType::IRPass);
     if (OptForSize)
       return nullptr;
 
-    Value *Len = emitStrLen(CI->getArgOperand(2), B, DL, TLI);
+    Value *Len = emitStrLen(CI->getArgOperand(2), B, DL, TLI, AATags);
     if (!Len)
       return nullptr;
     Value *IncLen =
         B.CreateAdd(Len, ConstantInt::get(Len->getType(), 1), "leninc");
     B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(2),
-                   Align(1), IncLen);
+                   Align(1), IncLen,
+                   false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
 
     // The sprintf result is the unincremented number of bytes in the string.
     return B.CreateIntCast(Len, CI->getType(), false);
   }
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeSPrintF(CallInst *CI, IRBuilderBase &B) {
if (!Size)
     return nullptr;
 
   uint64_t N = Size->getZExtValue();
   // Check for a fixed format string.
   StringRef FormatStr;
   if (!getConstantStringInfo(CI->getArgOperand(2), FormatStr))
     return nullptr;
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // If we just have a format string (nothing else crazy) transform it.
   if (CI->getNumArgOperands() == 3) {
     // Make sure there's no % in the constant array.  We could try to handle
     // %% -> % in the future if we cared.
     if (FormatStr.find('%') != StringRef::npos)
       return nullptr; // we found a format specifier, bail out.
 
     if (N == 0)
       return ConstantInt::get(CI->getType(), FormatStr.size());
     else if (N < FormatStr.size() + 1)
       return nullptr;
 
     // snprintf(dst, size, fmt) -> llvm.memcpy(align 1 dst, align 1 fmt,
     // strlen(fmt)+1)
     B.CreateMemCpy(
         CI->getArgOperand(0), Align(1), CI->getArgOperand(2), Align(1),
         ConstantInt::get(DL.getIntPtrType(CI->getContext()),
-                         FormatStr.size() + 1)); // Copy the null byte.
+                         FormatStr.size() + 1),
+        false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias); // Copy the null byte.
     return ConstantInt::get(CI->getType(), FormatStr.size());
   }
 
   // The remaining optimizations require the format string to be "%s" or "%c"
   // and have an extra operand.
   if (FormatStr.size() == 2 && FormatStr[0] == '%' &&
       CI->getNumArgOperands() == 4) {
 
if (FormatStr[1] == 's') {
         return nullptr;
 
       if (N == 0)
         return ConstantInt::get(CI->getType(), Str.size());
       else if (N < Str.size() + 1)
         return nullptr;
 
       B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(3),
-                     Align(1), ConstantInt::get(CI->getType(), Str.size() + 1));
+                     Align(1), ConstantInt::get(CI->getType(), Str.size() + 1),
+                     false, AATags.TBAA, nullptr, AATags.Scope, AATags.NoAlias);
 
       // The snprintf result is the unincremented number of bytes in the string.
       return ConstantInt::get(CI->getType(), Str.size());
     }
   }
   return nullptr;
 }
 
Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilderBase &B) {
   if (getConstantStringInfo(CI->getArgOperand(0), Str) && Str.empty())
     return emitPutChar(B.getInt32('\n'), B, TLI);
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeBCopy(CallInst *CI, IRBuilderBase &B) {
   // bcopy(src, dst, n) -> llvm.memmove(dst, src, n)
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   return B.CreateMemMove(CI->getArgOperand(1), Align(1), CI->getArgOperand(0),
-                         Align(1), CI->getArgOperand(2));
+                         Align(1), CI->getArgOperand(2),
+                         false, AATags.TBAA, AATags.Scope, AATags.NoAlias);
 }
 
 bool LibCallSimplifier::hasFloatVersion(StringRef FuncName) {
   LibFunc Func;
   SmallString<20> FloatFuncName = FuncName;
   FloatFuncName += 'f';
   if (TLI->getLibFunc(FloatFuncName, Func))
     return TLI->has(Func);
if (ConstantInt *ObjSizeCI =
     }
   }
   return false;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
                                                      IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 3, 2)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     CallInst *NewCI =
         B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
-                       Align(1), CI->getArgOperand(2));
+                       Align(1), CI->getArgOperand(2),
+                       false, AATags.TBAA, AATags.TBAAStruct, AATags.Scope, AATags.NoAlias);
     NewCI->setAttributes(CI->getAttributes());
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
                                                       IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 3, 2)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     CallInst *NewCI =
         B.CreateMemMove(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
-                        Align(1), CI->getArgOperand(2));
+                        Align(1), CI->getArgOperand(2),
+                        false, AATags.TBAA, AATags.Scope, AATags.NoAlias);
     NewCI->setAttributes(CI->getAttributes());
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
                                                      IRBuilderBase &B) {
   // TODO: Try foldMallocMemset() here.
 
   if (isFortifiedCallFoldable(CI, 3, 2)) {
     Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val,
-                                     CI->getArgOperand(2), Align(1));
+                                     CI->getArgOperand(2), Align(1),
+                                     false, AATags.TBAA, AATags.Scope, AATags.NoAlias);
     NewCI->setAttributes(CI->getAttributes());
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
                                                       IRBuilderBase &B,
                                                       LibFunc Func) {
   const DataLayout &DL = CI->getModule()->getDataLayout();
   Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1),
         *ObjSize = CI->getArgOperand(2);
 
+  AAMDNodes AATags;
+  CI->getAAMetadata(AATags);
   // __stpcpy_chk(x,x,...)  -> x+strlen(x)
   if (Func == LibFunc_stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) {
-    Value *StrLen = emitStrLen(Src, B, DL, TLI);
+    Value *StrLen = emitStrLen(Src, B, DL, TLI, AATags);
     return StrLen ? B.CreateInBoundsGEP(B.getInt8Ty(), Dst, StrLen) : nullptr;
   }
 
   // If a) we don't have any length information, or b) we know this will
   // fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
   // st[rp]cpy_chk call which may fail at runtime if the size is too long.
   // TODO: It might be nice to get a maximum length out of the possible
   // string lengths for varying.
   if (isFortifiedCallFoldable(CI, 2, None, 1)) {
     if (Func == LibFunc_strcpy_chk)
-      return emitStrCpy(Dst, Src, B, TLI);
+      return emitStrCpy(Dst, Src, B, TLI, AATags);
     else
-      return emitStpCpy(Dst, Src, B, TLI);
+      return emitStpCpy(Dst, Src, B, TLI, AATags);
   }
 
   if (OnlyLowerUnknownSize)
     return nullptr;
 
   // Maybe we can stil fold __st[rp]cpy_chk to __memcpy_chk.
   uint64_t Len = GetStringLength(Src);
   if (Len)
     annotateDereferenceableBytes(CI, 1, Len);
   else
     return nullptr;
 
   Type *SizeTTy = DL.getIntPtrType(CI->getContext());
   Value *LenV = ConstantInt::get(SizeTTy, Len);
-  Value *Ret = emitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI);
+  Value *Ret = emitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI, AATags);
   // If the function was an __stpcpy_chk, and we were able to fold it into
   // a __memcpy_chk, we still need to return the correct end pointer.
   if (Ret && Func == LibFunc_stpcpy_chk)
     return B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(SizeTTy, Len - 1));
   return Ret;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrLenChk(CallInst *CI,
                                                      IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 1, None, 0))
+  if (isFortifiedCallFoldable(CI, 1, None, 0)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitStrLen(CI->getArgOperand(0), B, CI->getModule()->getDataLayout(),
-                      TLI);
+                      TLI, AATags);
+  }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(CallInst *CI,
                                                        IRBuilderBase &B,
                                                        LibFunc Func) {
   if (isFortifiedCallFoldable(CI, 3, 2)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     if (Func == LibFunc_strncpy_chk)
       return emitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
-                               CI->getArgOperand(2), B, TLI);
+                         CI->getArgOperand(2), B, TLI, AATags);
     else
       return emitStpNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
-                         CI->getArgOperand(2), B, TLI);
+                         CI->getArgOperand(2), B, TLI, AATags);
   }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemCCpyChk(CallInst *CI,
                                                       IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 4, 3))
+  if (isFortifiedCallFoldable(CI, 4, 3)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitMemCCpy(CI->getArgOperand(0), CI->getArgOperand(1),
-                       CI->getArgOperand(2), CI->getArgOperand(3), B, TLI);
+                       CI->getArgOperand(2), CI->getArgOperand(3), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeSNPrintfChk(CallInst *CI,
                                                        IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 3, 1, None, 2)) {
     SmallVector<Value *, 8> VariadicArgs(CI->arg_begin() + 5, CI->arg_end());
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitSNPrintf(CI->getArgOperand(0), CI->getArgOperand(1),
-                        CI->getArgOperand(4), VariadicArgs, B, TLI);
+                        CI->getArgOperand(4), VariadicArgs, B, TLI, AATags);
   }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeSPrintfChk(CallInst *CI,
                                                       IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 2, None, None, 1)) {
     SmallVector<Value *, 8> VariadicArgs(CI->arg_begin() + 4, CI->arg_end());
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitSPrintf(CI->getArgOperand(0), CI->getArgOperand(3), VariadicArgs,
-                       B, TLI);
+                       B, TLI, AATags);
   }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrCatChk(CallInst *CI,
                                                      IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 2))
-    return emitStrCat(CI->getArgOperand(0), CI->getArgOperand(1), B, TLI);
+  if (isFortifiedCallFoldable(CI, 2)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
+    return emitStrCat(CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrLCat(CallInst *CI,
                                                    IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 3))
+  if (isFortifiedCallFoldable(CI, 3)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitStrLCat(CI->getArgOperand(0), CI->getArgOperand(1),
-                       CI->getArgOperand(2), B, TLI);
+                       CI->getArgOperand(2), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrNCatChk(CallInst *CI,
                                                       IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 3))
+  if (isFortifiedCallFoldable(CI, 3)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitStrNCat(CI->getArgOperand(0), CI->getArgOperand(1),
-                       CI->getArgOperand(2), B, TLI);
+                       CI->getArgOperand(2), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeStrLCpyChk(CallInst *CI,
                                                       IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 3))
+  if (isFortifiedCallFoldable(CI, 3)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitStrLCpy(CI->getArgOperand(0), CI->getArgOperand(1),
-                       CI->getArgOperand(2), B, TLI);
+                       CI->getArgOperand(2), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeVSNPrintfChk(CallInst *CI,
                                                         IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 3, 1, None, 2))
+  if (isFortifiedCallFoldable(CI, 3, 1, None, 2)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitVSNPrintf(CI->getArgOperand(0), CI->getArgOperand(1),
-                         CI->getArgOperand(4), CI->getArgOperand(5), B, TLI);
+                         CI->getArgOperand(4), CI->getArgOperand(5), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeVSPrintfChk(CallInst *CI,
                                                        IRBuilderBase &B) {
-  if (isFortifiedCallFoldable(CI, 2, None, None, 1))
+  if (isFortifiedCallFoldable(CI, 2, None, None, 1)) {
+    AAMDNodes AATags;
+    CI->getAAMetadata(AATags);
     return emitVSPrintf(CI->getArgOperand(0), CI->getArgOperand(3),
-                        CI->getArgOperand(4), B, TLI);
+                        CI->getArgOperand(4), B, TLI, AATags);
+  }
 
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI,
                                                 IRBuilderBase &Builder) {
   // FIXME: We shouldn't be changing "nobuiltin" or TLI unavailable calls here.
   // Some clang users checked for _chk libcall availability using: