[noalias.decl] Look through llvm.experimental.noalias.scope.decl

[jeroen.dobbelaere]

Summary

Just like llvm.assume, there are a lot of cases where we can just ignore llvm.experimental.noalias.scope.decl.

[jeroen.dobbelaere]

Rebased and updated to the new naming

[jeroen.dobbelaere]

The vectorizer should handle the 'MetadataAsValue' type as a scalar type.

[nikic]

The changes here all look reasonable to me. Ideally we would add test cases for the individual passes and land this before changing inlining, such that the inlining change by itself does not cause undue regressions.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

1752

This doesn't do anything :)

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

2554

I guess this makes sense with the full version (that accepts an alloca). I don't think this can happen currently.

[jeroen.dobbelaere]

• update according to comments
• prepared for different patch order

[jeroen.dobbelaere]

FYI: I'll add testcases for the different parts later today

[jeroen.dobbelaere]

The guidance for these changes are mostly based on '::assume'. For some changes, I did not find a corresponding (breaking) assume test, so I did not add one for ::experimental_noalias_scope_decl.
For the others I did add testcases.
The change in BasicAliasAnalysis seemed not to be needed to get the testcase working, so I removed the BasicAliasAnalysis changes, but kept the testcase.
For the Vectorization. I currently focused on still allowing vectorization and reducing the amount of intrinsics duplication. It is likely that some finetuning will be needed in future to tackle correctness, but, with this patch, the situation should not be worse that what it is today.

[nikic]

LGTM

llvm/test/Transforms/EarlyCSE/noalias_scope_decl.ll

3 ↗

(On Diff #316993)

across a @llvm.experimental.noalais.scope.decl

14 ↗

(On Diff #316993)

same

31 ↗

(On Diff #316993)

For this kind of test, using update_test_checks.py with untouched output would be preferred.

[jeroen.dobbelaere]

Adapted to comments

[jeroen.dobbelaere]

Oops. Adapted to comments (but now for real).

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

unsigned getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
     case Intrinsic::dbg_label:
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::launder_invariant_group:
     case Intrinsic::strip_invariant_group:
     case Intrinsic::is_constant:
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
+    case Intrinsic::noalias_decl:
     case Intrinsic::objectsize:
     case Intrinsic::ptr_annotation:
     case Intrinsic::var_annotation:
     case Intrinsic::experimental_gc_result:
     case Intrinsic::experimental_gc_relocate:
     case Intrinsic::coro_alloc:
     case Intrinsic::coro_begin:
     case Intrinsic::coro_free:

llvm/lib/Analysis/AliasSetTracker.cpp

void AliasSetTracker::addUnknown(Instruction *Inst) {
   if (auto *II = dyn_cast<IntrinsicInst>(Inst)) {
     // These intrinsics will show up as affecting memory, but they are just
     // markers.
     switch (II->getIntrinsicID()) {
     default:
       break;
       // FIXME: Add lifetime/invariant intrinsics (See: PR30807).
     case Intrinsic::assume:
+    case Intrinsic::noalias_decl:
     case Intrinsic::sideeffect:
     case Intrinsic::pseudoprobe:
       return;
     }
   }
   if (!Inst->mayReadOrWriteMemory())
     return; // doesn't alias anything
 

llvm/lib/Analysis/BasicAliasAnalysis.cpp

ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
   }
 
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
   if (isIntrinsicCall(Call, Intrinsic::assume))
     return ModRefInfo::NoModRef;
 
+  // The same is true for the llvm.noalias.decl intrinsic.
+  if (isIntrinsicCall(Call, Intrinsic::noalias_decl))
+    return ModRefInfo::NoModRef;
+
   // Like assumes, guard intrinsics are also marked as arbitrarily writing so
   // that proper control dependencies are maintained but they never mods any
   // particular memory location.
   //
   // *Unlike* assumes, guard intrinsics are modeled as reading memory since the
   // heap state at the point the guard is issued needs to be consistent in case
   // the guard invokes the "deopt" continuation.
   if (isIntrinsicCall(Call, Intrinsic::experimental_guard))
ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call1,
                                         AAQueryInfo &AAQI) {
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
   if (isIntrinsicCall(Call1, Intrinsic::assume) ||
       isIntrinsicCall(Call2, Intrinsic::assume))
     return ModRefInfo::NoModRef;
 
+  // The same is true for the llvm.noalias.decl intrinsic.
+  if (isIntrinsicCall(Call1, Intrinsic::noalias_decl) ||
+      isIntrinsicCall(Call2, Intrinsic::noalias_decl))
+    return ModRefInfo::NoModRef;
+
   // Like assumes, guard intrinsics are also marked as arbitrarily writing so
   // that proper control dependencies are maintained but they never mod any
   // particular memory location.
   //
   // *Unlike* assumes, guard intrinsics are modeled as reading memory since the
   // heap state at the point the guard is issued needs to be consistent in case
   // the guard invokes the "deopt" continuation.
 

llvm/lib/Analysis/MemorySSA.cpp

if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(DefInst)) {
     // (including creating MemoryAccesses for them): we just end up inventing
     // clobbers where they don't really exist at all. Please see D43269 for
     // context.
     switch (II->getIntrinsicID()) {
     case Intrinsic::lifetime_end:
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::assume:
+    case Intrinsic::noalias_decl:
       return {false, NoAlias};
     case Intrinsic::dbg_addr:
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_label:
     case Intrinsic::dbg_value:
       llvm_unreachable("debuginfo shouldn't have associated defs!");
     default:
       break;
MemoryUseOrDef *MemorySSA::createNewAccess(Instruction *I,
                                            AliasAnalysisType *AAP,
                                            const MemoryUseOrDef *Template) {
   // The assume intrinsic has a control dependency which we model by claiming
   // that it writes arbitrarily. Debuginfo intrinsics may be considered
   // clobbers when we have a nonstandard AA pipeline. Ignore these fake memory
   // dependencies here.
   // FIXME: Replace this special casing with a more accurate modelling of
   // assume's control dependency.
-  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I))
-    if (II->getIntrinsicID() == Intrinsic::assume)
+  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
+    switch (II->getIntrinsicID()) {
+    default:
+      break;
+    case Intrinsic::assume:
+    case Intrinsic::noalias_decl:
       return nullptr;
+    }
+  }
 
   // Using a nonstandard AA pipelines might leave us with unexpected modref
   // results for I, so add a check to not model instructions that may not read
   // from or write to memory. This is necessary for correctness.
   if (!I->mayReadFromMemory() && !I->mayWriteToMemory())
     return nullptr;
 
   bool Def, Use;

llvm/lib/Analysis/ValueTracking.cpp

if (Function *F = CI->getCalledFunction())
       case Intrinsic::pseudoprobe:
       case Intrinsic::dbg_declare:
       case Intrinsic::dbg_value:
       case Intrinsic::dbg_label:
       case Intrinsic::invariant_start:
       case Intrinsic::invariant_end:
       case Intrinsic::lifetime_start:
       case Intrinsic::lifetime_end:
+      case Intrinsic::noalias_decl:
       case Intrinsic::objectsize:
       case Intrinsic::ptr_annotation:
       case Intrinsic::var_annotation:
         return true;
       }
 
   return false;
 }

llvm/lib/Analysis/VectorUtils.cpp

 Intrinsic::ID llvm::getVectorIntrinsicIDForCall(const CallInst *CI,
                                                 const TargetLibraryInfo *TLI) {
   Intrinsic::ID ID = getIntrinsicForCallSite(*CI, TLI);
   if (ID == Intrinsic::not_intrinsic)
     return Intrinsic::not_intrinsic;
 
   if (isTriviallyVectorizable(ID) || ID == Intrinsic::lifetime_start ||
       ID == Intrinsic::lifetime_end || ID == Intrinsic::assume ||
-      ID == Intrinsic::sideeffect || ID == Intrinsic::pseudoprobe)
+      ID == Intrinsic::noalias_decl || ID == Intrinsic::sideeffect ||
+      ID == Intrinsic::pseudoprobe)
     return ID;
   return Intrinsic::not_intrinsic;
 }
 
 /// Find the operand of the GEP that should be checked for consecutive
 /// stores. This ignores trailing indices that have no effect on the final
 /// pointer.
 unsigned llvm::getGEPInductionOperand(const GetElementPtrInst *Gep) {

llvm/lib/CodeGen/Analysis.cpp

for (BasicBlock::const_iterator BBI = std::prev(ExitBB->end(), 2);; --BBI) {
     if (&*BBI == &Call)
       break;
     // Debug info intrinsics do not get in the way of tail call optimization.
     if (isa<DbgInfoIntrinsic>(BBI))
       continue;
     // Pseudo probe intrinsics do not block tail call optimization either.
     if (isa<PseudoProbeInst>(BBI))
       continue;
-    // A lifetime end or assume intrinsic should not stop tail call
-    // optimization.
+    // A lifetime end, assume or noalias.decl intrinsic should not stop tail
+    // call optimization.
     if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(BBI))
       if (II->getIntrinsicID() == Intrinsic::lifetime_end ||
-          II->getIntrinsicID() == Intrinsic::assume)
+          II->getIntrinsicID() == Intrinsic::assume ||
+          II->getIntrinsicID() == Intrinsic::noalias_decl)
         continue;
     if (BBI->mayHaveSideEffects() || BBI->mayReadFromMemory() ||
         !isSafeToSpeculativelyExecute(&*BBI))
       return false;
   }
 
   const Function *F = ExitBB->getParent();
   return returnTypeIsEligibleForTailCall(

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (DstTy && VecTy) {
 
       Value *Shuffle =
           Builder.CreateShuffleVector(Vec, UndefValue::get(VecTy), Mask);
       replaceInstUsesWith(CI, Shuffle);
       return eraseInstFromFunction(CI);
     }
     break;
   }
+  case Intrinsic::noalias_decl:
+    break;
   default: {
     // Handle target specific intrinsics
     Optional<Instruction *> V = targetInstCombineIntrinsic(*II);
     if (V.hasValue())
       return V.getValue();
     break;
   }
   }

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

for (User *U : PI->users()) {
             LLVM_FALLTHROUGH;
           }
           case Intrinsic::assume:
           case Intrinsic::invariant_start:
           case Intrinsic::invariant_end:
           case Intrinsic::lifetime_start:
           case Intrinsic::lifetime_end:
           case Intrinsic::objectsize:
+          case Intrinsic::noalias_decl:
             Users.emplace_back(I);
             continue;
           }
         }
 
         if (isFreeCall(I, TLI)) {
           Users.emplace_back(I);
           continue;

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

if (match(&Inst, m_Intrinsic<Intrinsic::assume>())) {
         LLVM_DEBUG(dbgs() << "EarlyCSE considering assumption: " << Inst
                           << '\n');
         AvailableValues.insert(CondI, ConstantInt::getTrue(BB->getContext()));
       } else
         LLVM_DEBUG(dbgs() << "EarlyCSE skipping assumption: " << Inst << '\n');
       continue;
     }
 
+    // Likewise, noalias intrinsics don't actually write.
+    if (match(&Inst, m_Intrinsic<Intrinsic::noalias_decl>())) {
+      LLVM_DEBUG(dbgs() << "EarlyCSE skipping noalias intrinsic: " << Inst
+                        << '\n');
+      continue;
+    }
+
     // Skip sideeffect intrinsics, for the same reason as assume intrinsics.
     if (match(&Inst, m_Intrinsic<Intrinsic::sideeffect>())) {
       LLVM_DEBUG(dbgs() << "EarlyCSE skipping sideeffect: " << Inst << '\n');
       continue;
     }
 
     // We can skip all invariant.start intrinsics since they only read memory,
     // and we can forward values across it. For invariant starts without

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

 ; OPM-NEXT:    call i8* @llvm.noalias.decl
 ; OPM-NEXT:    call i8* @llvm.noalias.decl
 ; OPM-NEXT:    store i32 7, i32* [[SLOT]], align 4
 ; OPM-NEXT:    call i8* @llvm.noalias.decl
 ; OPM-NEXT:    call void @print(i32 7)
 
 ;  FIXME: After introduction of llvm.noalias.decl, this is not fully optimzed
 ;  with the new pass manager.
-; NPM-NEXT:    store i32 1, i32* [[SLOT]], align 4
 ; NPM-NEXT:    call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64
-; NPM-NEXT:    [[RELOAD0:%.+]] = load i32, i32* [[SLOT]], align 4
-; NPM-NEXT:    [[SUM0:%.+]] = add i32 [[RELOAD0]], 2
-; NPM-NEXT:    store i32 [[SUM0]], i32* [[SLOT]], align 4
 ; NPM-NEXT:    call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64
-; NPM-NEXT:    [[RELOAD1:%.+]] = load i32, i32* [[SLOT]], align 4
-; NPM-NEXT:    [[SUM2:%.+]] = add i32 [[RELOAD1]], 4
-; NPM-NEXT:    store i32 [[SUM2]], i32* [[SLOT]], align 4
+; NPM-NEXT:    store i32 7, i32* [[SLOT]], align 4
 ; NPM-NEXT:    call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64
 ; NPM-NEXT:    [[RELOAD2:%.+]] = load i32, i32* [[SLOT]], align 4
 ; NPM-NEXT:    call void @print(i32 [[RELOAD2]])
 
 ; CHECK-NEXT:    ret i32 0
 
 declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*)
 declare i8* @llvm.coro.begin(token, i8*)