[AssumeBundles] Preserve Information in the inliner

[Tyker]

Summary

during inling Create and insert an llvm.assume with attributes to preserve them.
to prevent any changes for now generation of llvm.assume is under a flag disabled by default.

[jdoerfert]

llvm/test/Transforms/Inline/arg-attr-propagation.ll

3

Call file check with --check-prefixes=CHECK,NO_ASSUME and --check-prefixes=CHECK,USE_ASSUME. When you rerun the update script (with --function-signatures!) it will fold the same output of both runs

llvm/test/Transforms/Inline/noalias2.ll

3

Same as above.

[Tyker]

Addressed review comment.

[jdoerfert]

LGTM.

[jeroen.dobbelaere]

llvm/test/Transforms/Inline/noalias2.ll

3

@jdoerfert, @ Tyker This test is partly bogus. The 'ASUME' checks will never be triggered. In D75828, the USE_ASSUME is also replaced by ASSUME, but the driver is not modified. Can I just omit the ASUME part ?

[jdoerfert]

llvm/test/Transforms/Inline/noalias2.ll

3

Yeah, you should be able to rerun utils/update_test_checks.py after removing "check lines".

llvm/lib/IR/KnowledgeRetention.cpp

 
 using namespace llvm;
 
 cl::opt<bool> ShouldPreserveAllAttributes(
     "assume-preserve-all", cl::init(false), cl::Hidden,
     cl::desc("enable preservation of all attrbitues. even those that are "
              "unlikely to be usefull"));
 
+cl::opt<bool> EnableKnowledgeRetention(
+    "enable-knowledge-retention", cl::init(false), cl::Hidden,
+    cl::desc(
+        "enable preservation of attributes throughout code transformation"));
+
 namespace {
 
 struct AssumedKnowledge {
   const char *Name;
   Value *Argument;
   enum {
     None,
     Empty,
void addInstruction(const Instruction *I) {
     // TODO: Add support for the other Instructions.
     // TODO: Maybe we should look around and merge with other llvm.assume.
   }
 };
 
 } // namespace
 
 CallInst *llvm::BuildAssumeFromInst(const Instruction *I, Module *M) {
+  if (!EnableKnowledgeRetention)
+    return nullptr;
   AssumeBuilderState Builder(M);
   Builder.addInstruction(I);
   return Builder.build();
 }
 
 static bool BundleHasArguement(const CallBase::BundleOpInfo &BOI,
                                unsigned Idx) {
   return BOI.End - BOI.Begin > Idx;

llvm/lib/Transforms/Utils/InlineFunction.cpp

 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"

 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/KnowledgeRetention.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <iterator>
 #include <limits>
 #include <string>
 #include <utility>
for (Function::arg_iterator I = CalledFunc->arg_begin(),
                                         CalledFunc->getParamAlignment(ArgNo));
         if (ActualArg != *AI)
           ByValInit.push_back(std::make_pair(ActualArg, (Value*) *AI));
       }
 
       VMap[&*I] = ActualArg;
     }
 
+    // TODO: Remove this when users have been updated to the assume bundles.
     // Add alignment assumptions if necessary. We do this before the inlined
     // instructions are actually cloned into the caller so that we can easily
     // check what will be known at the start of the inlined code.
     AddAlignmentAssumptions(CS, IFI);
 
+    /// Preserve all attributes on of the call and its parameters.
+    if (Instruction* Assume = BuildAssumeFromInst(CS.getInstruction()))
+      Assume->insertBefore(CS.getInstruction());
+
     // We want the inliner to prune the code as it copies.  We would LOVE to
     // have no dead or constant instructions leftover after inlining occurs
     // (which can happen, e.g., because an argument was constant), but we'll be
     // happy with whatever the cloner can do.
     CloneAndPruneFunctionInto(Caller, CalledFunc, VMap,
                               /*ModuleLevelChanges=*/false, Returns, ".i",
                               &InlinedFunctionInfo, TheCall);
     // Remember the first block that is newly cloned over.

llvm/test/IR/assume-builder.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes='assume-builder,verify' -S %s | FileCheck %s --check-prefixes=BASIC
-; RUN: opt -passes='assume-builder,verify' --assume-preserve-all -S %s | FileCheck %s --check-prefixes=ALL
+; RUN: opt -passes='assume-builder,verify' --enable-knowledge-retention -S %s | FileCheck %s --check-prefixes=BASIC
+; RUN: opt -passes='assume-builder,verify' --enable-knowledge-retention --assume-preserve-all -S %s | FileCheck %s --check-prefixes=ALL
 
 declare void @func(i32*, i32*)
 declare void @func_cold(i32*) cold
 declare void @func_strbool(i32*) "no-jump-tables"
 declare void @func_many(i32*) "no-jump-tables" nounwind "less-precise-fpmad" willreturn norecurse
 declare void @func_argattr(i32* align 8, i32* nonnull) nounwind
 
 define void @test(i32* %P, i32* %P1, i32* %P2, i32* %P3) {

llvm/test/Transforms/Inline/arg-attr-propagation.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -inline -S --enable-knowledge-retention < %s | FileCheck %s --check-prefix=ASSUME
 
 ; The callee guarantees that the pointer argument is nonnull and dereferenceable.
 ; That information should transfer to the caller.
 
 define i32 @callee(i32* dereferenceable(32) %t1) {
-; CHECK-LABEL: @callee(i32* dereferenceable(32) %t1)
-; CHECK-NEXT:    [[T2:%.*]] = load i32, i32* %t1
+; CHECK-LABEL: @callee(
+; CHECK-NEXT:    [[T2:%.*]] = load i32, i32* [[T1:%.*]]
 ; CHECK-NEXT:    ret i32 [[T2]]
 ;
+; ASSUME-LABEL: @callee(
+; ASSUME-NEXT:    [[T2:%.*]] = load i32, i32* [[T1:%.*]]
+; ASSUME-NEXT:    ret i32 [[T2]]
+;
   %t2 = load i32, i32* %t1
   ret i32 %t2
 }
 
 ; FIXME: All dereferenceability information is lost.
 ; The caller argument could be known nonnull and dereferenceable(32).
 
 define i32 @caller1(i32* %t1) {
-; CHECK-LABEL: @caller1(i32* %t1)
-; CHECK-NEXT:    [[T2_I:%.*]] = load i32, i32* %t1
+; CHECK-LABEL: @caller1(
+; CHECK-NEXT:    [[T2_I:%.*]] = load i32, i32* [[T1:%.*]]
 ; CHECK-NEXT:    ret i32 [[T2_I]]
 ;
+; ASSUME-LABEL: @caller1(
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[T1:%.*]], i64 32) ]
+; ASSUME-NEXT:    [[T2_I:%.*]] = load i32, i32* [[T1]]
+; ASSUME-NEXT:    ret i32 [[T2_I]]
+;
   %t2 = tail call i32 @callee(i32* dereferenceable(32) %t1)
   ret i32 %t2
 }
 
 ; The caller argument is nonnull, but that can be explicit.
 ; The dereferenceable amount could be increased.
 
 define i32 @caller2(i32* dereferenceable(31) %t1) {
-; CHECK-LABEL: @caller2(i32* dereferenceable(31) %t1)
-; CHECK-NEXT:    [[T2_I:%.*]] = load i32, i32* %t1
+; CHECK-LABEL: @caller2(
+; CHECK-NEXT:    [[T2_I:%.*]] = load i32, i32* [[T1:%.*]]
 ; CHECK-NEXT:    ret i32 [[T2_I]]
 ;
+; ASSUME-LABEL: @caller2(
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[T1:%.*]], i64 32) ]
+; ASSUME-NEXT:    [[T2_I:%.*]] = load i32, i32* [[T1]]
+; ASSUME-NEXT:    ret i32 [[T2_I]]
+;
   %t2 = tail call i32 @callee(i32* dereferenceable(32) %t1)
   ret i32 %t2
 }
 
 ; The caller argument is nonnull, but that can be explicit.
 ; Make sure that we don't propagate a smaller dereferenceable amount.
 
 define i32 @caller3(i32* dereferenceable(33) %t1) {
-; CHECK-LABEL: @caller3(i32* dereferenceable(33) %t1)
-; CHECK-NEXT:    [[T2_I:%.*]] = load i32, i32* %t1
+; CHECK-LABEL: @caller3(
+; CHECK-NEXT:    [[T2_I:%.*]] = load i32, i32* [[T1:%.*]]
 ; CHECK-NEXT:    ret i32 [[T2_I]]
 ;
+; ASSUME-LABEL: @caller3(
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[T1:%.*]], i64 32) ]
+; ASSUME-NEXT:    [[T2_I:%.*]] = load i32, i32* [[T1]]
+; ASSUME-NEXT:    ret i32 [[T2_I]]
+;
   %t2 = tail call i32 @callee(i32* dereferenceable(32) %t1)
   ret i32 %t2
 }
 

llvm/test/Transforms/Inline/noalias2.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -inline -enable-noalias-to-md-conversion --enable-knowledge-retention -S < %s | FileCheck %s --check-prefix=ASSUME
+
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @hello(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
+; CHECK-LABEL: @hello(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    ret void
+;
+; ASSUME-LABEL: @hello(
+; ASSUME-NEXT:  entry:
+; ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4
+; ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
+; ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX]], align 4
+; ASSUME-NEXT:    ret void
+;
 entry:
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 5
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
 define void @foo(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4, !alias.scope !0, !noalias !3
+; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !3, !noalias !0
+; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    ret void
+;
+; ASSUME-LABEL: @foo(
+; ASSUME-NEXT:  entry:
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "noalias"(float* [[A:%.*]]), "noalias"(float* [[C:%.*]]), "nocapture"(float* [[A]]), "nocapture"(float* [[C]]), "readonly"(float* [[C]]) ]
+; ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !0, !noalias !3
+; ASSUME-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
+; ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !3, !noalias !0
+; ASSUME-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
+; ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; ASSUME-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
+; ASSUME-NEXT:    ret void
+;
 entry:
   tail call void @hello(float* %a, float* %c)
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
-; CHECK: define void @foo(float* noalias nocapture %a, float* noalias nocapture readonly %c) #0 {
-; CHECK: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !alias.scope !0, !noalias !3
-; CHECK:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
-; CHECK:   store float %0, float* %arrayidx.i, align 4, !alias.scope !3, !noalias !0
-; CHECK:   %1 = load float, float* %c, align 4
-; CHECK:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx, align 4
-; CHECK:   ret void
-; CHECK: }
-
 define void @hello2(float* noalias nocapture %a, float* noalias nocapture %b, float* nocapture readonly %c) #0 {
+; CHECK-LABEL: @hello2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 6
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i64 8
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX1]], align 4
+; CHECK-NEXT:    ret void
+;
+; ASSUME-LABEL: @hello2(
+; ASSUME-NEXT:  entry:
+; ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4
+; ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 6
+; ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX]], align 4
+; ASSUME-NEXT:    [[ARRAYIDX1:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i64 8
+; ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX1]], align 4
+; ASSUME-NEXT:    ret void
+;
 entry:
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 6
   store float %0, float* %arrayidx, align 4
   %arrayidx1 = getelementptr inbounds float, float* %b, i64 8
   store float %0, float* %arrayidx1, align 4
   ret void
 }
 
 ; Check that when hello() is inlined into foo(), and then foo() is inlined into
 ; foo2(), the noalias scopes are properly concatenated.
 define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
+; CHECK-LABEL: @foo2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load float, float* [[C:%.*]], align 4, !alias.scope !5, !noalias !10
+; CHECK-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds float, float* [[A:%.*]], i64 5
+; CHECK-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !10, !noalias !5
+; CHECK-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !alias.scope !13, !noalias !14
+; CHECK-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; CHECK-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !alias.scope !14, !noalias !13
+; CHECK-NEXT:    [[TMP2:%.*]] = load float, float* [[C]], align 4, !noalias !15
+; CHECK-NEXT:    [[ARRAYIDX_I1:%.*]] = getelementptr inbounds float, float* [[A]], i64 6
+; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I1]], align 4, !alias.scope !19, !noalias !20
+; CHECK-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B:%.*]], i64 8
+; CHECK-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !20, !noalias !19
+; CHECK-NEXT:    [[TMP3:%.*]] = load float, float* [[C]], align 4
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; CHECK-NEXT:    store float [[TMP3]], float* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    ret void
+;
+; ASSUME-LABEL: @foo2(
+; ASSUME-NEXT:  entry:
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "noalias"(float* [[A:%.*]]), "noalias"(float* [[C:%.*]]), "nocapture"(float* [[A]]), "nocapture"(float* [[C]]), "readonly"(float* [[C]]) ]
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) #2 [ "noalias"(float* [[A]]), "noalias"(float* [[C]]), "nocapture"(float* [[A]]), "nocapture"(float* [[C]]), "readonly"(float* [[C]]) ], !noalias !5
+; ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !9, !noalias !12
+; ASSUME-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
+; ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !12, !noalias !9
+; ASSUME-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !alias.scope !14, !noalias !15
+; ASSUME-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; ASSUME-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !alias.scope !15, !noalias !14
+; ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "noalias"(float* [[A]]), "noalias"(float* [[B:%.*]]), "nocapture"(float* [[A]]), "nocapture"(float* [[B]]), "nocapture"(float* [[C]]), "readonly"(float* [[C]]) ]
+; ASSUME-NEXT:    [[TMP2:%.*]] = load float, float* [[C]], align 4, !noalias !16
+; ASSUME-NEXT:    [[ARRAYIDX_I1:%.*]] = getelementptr inbounds float, float* [[A]], i64 6
+; ASSUME-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I1]], align 4, !alias.scope !20, !noalias !21
+; ASSUME-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B]], i64 8
+; ASSUME-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !21, !noalias !20
+; ASSUME-NEXT:    [[TMP3:%.*]] = load float, float* [[C]], align 4
+; ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
+; ASSUME-NEXT:    store float [[TMP3]], float* [[ARRAYIDX]], align 4
+; ASSUME-NEXT:    ret void
+;
 entry:
   tail call void @foo(float* %a, float* %c)
   tail call void @hello2(float* %a, float* %b, float* %c)
   %0 = load float, float* %c, align 4
   %arrayidx = getelementptr inbounds float, float* %a, i64 7
   store float %0, float* %arrayidx, align 4
   ret void
 }
 
-; CHECK: define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
-; CHECK: entry:
-; CHECK:   %0 = load float, float* %c, align 4, !alias.scope !5, !noalias !10
-; CHECK:   %arrayidx.i.i = getelementptr inbounds float, float* %a, i64 5
-; CHECK:   store float %0, float* %arrayidx.i.i, align 4, !alias.scope !10, !noalias !5
-; CHECK:   %1 = load float, float* %c, align 4, !alias.scope !13, !noalias !14
-; CHECK:   %arrayidx.i = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %1, float* %arrayidx.i, align 4, !alias.scope !14, !noalias !13
-; CHECK:   %2 = load float, float* %c, align 4, !noalias !15
-; CHECK:   %arrayidx.i1 = getelementptr inbounds float, float* %a, i64 6
-; CHECK:   store float %2, float* %arrayidx.i1, align 4, !alias.scope !19, !noalias !20
-; CHECK:   %arrayidx1.i = getelementptr inbounds float, float* %b, i64 8
-; CHECK:   store float %2, float* %arrayidx1.i, align 4, !alias.scope !20, !noalias !19
-; CHECK:   %3 = load float, float* %c, align 4
-; CHECK:   %arrayidx = getelementptr inbounds float, float* %a, i64 7
-; CHECK:   store float %3, float* %arrayidx, align 4
-; CHECK:   ret void
-; CHECK: }
-
 ; CHECK: !0 = !{!1}
 ; CHECK: !1 = distinct !{!1, !2, !"hello: %c"}
 ; CHECK: !2 = distinct !{!2, !"hello"}
 ; CHECK: !3 = !{!4}
 ; CHECK: !4 = distinct !{!4, !2, !"hello: %a"}
 ; CHECK: !5 = !{!6, !8}
 ; CHECK: !6 = distinct !{!6, !7, !"hello: %c"}
 ; CHECK: !7 = distinct !{!7, !"hello"}

llvm/unittests/IR/KnowledgeRetentionTest.cpp

 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/CommandLine.h"
 #include "gtest/gtest.h"
 #include <random>
 
 using namespace llvm;
 
 extern cl::opt<bool> ShouldPreserveAllAttributes;
+extern cl::opt<bool> EnableKnowledgeRetention;
 
 static void RunTest(
     StringRef Head, StringRef Tail,
     std::vector<std::pair<StringRef, llvm::function_ref<void(Instruction *)>>>
         &Tests) {
   for (auto &Elem : Tests) {
     std::string IR;
     IR.append(Head.begin(), Head.end());
if (ResultLow != ResultHigh || ResultHigh == false) {
     ASSERT_TRUE(false);
   }
   if (ArgValLow != Value || ArgValLow != ArgValHigh) {
     ASSERT_TRUE(false);
   }
 }
 
 TEST(AssumeQueryAPI, hasAttributeInAssume) {
+  EnableKnowledgeRetention.setValue(true);
   StringRef Head =
       "declare void @llvm.assume(i1)\n"
       "declare void @func(i32*, i32*)\n"
       "declare void @func1(i32*, i32*, i32*, i32*)\n"
       "declare void @func_many(i32*) \"no-jump-tables\" nounwind "
       "\"less-precise-fpmad\" willreturn norecurse\n"
       "define void @test(i32* %P, i32* %P1, i32* %P2, i32* %P3) {\n";
   StringRef Tail = "ret void\n"
TEST(AssumeQueryAPI, hasAttributeInAssume) {
   RunTest(Head, Tail, Tests);
 }
 
 static void AssertFindExactlyAttributes(RetainedKnowledgeMap &Map, Value *WasOn,
                                  StringRef AttrToMatch) {
   Regex Reg(AttrToMatch);
   SmallVector<StringRef, 1> Matches;
   for (StringRef Attr : {
 #define GET_ATTR_NAMES
 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) StringRef(#DISPLAY_NAME),
 #include "llvm/IR/Attributes.inc"
        }) {
     bool ShouldHaveAttr = Reg.match(Attr, &Matches) && Matches[0] == Attr;
 
     if (ShouldHaveAttr != (Map.find(RetainedKnowledgeKey{WasOn, Attribute::getAttrKindFromName(Attr)}) != Map.end())) {
       ASSERT_TRUE(false);
     }
   }
 }
 
 static void AssertMapHasRightValue(RetainedKnowledgeMap &Map,
                                    RetainedKnowledgeKey Key, MinMax MM) {
   auto LookupIt = Map.find(Key);
   ASSERT_TRUE(LookupIt != Map.end());
   ASSERT_TRUE(LookupIt->second.Min == MM.Min);
   ASSERT_TRUE(LookupIt->second.Max == MM.Max);
 }
 
 TEST(AssumeQueryAPI, fillMapFromAssume) {
+    EnableKnowledgeRetention.setValue(true);
     StringRef Head =
       "declare void @llvm.assume(i1)\n"
       "declare void @func(i32*, i32*)\n"
       "declare void @func1(i32*, i32*, i32*, i32*)\n"
       "declare void @func_many(i32*) \"no-jump-tables\" nounwind "
       "\"less-precise-fpmad\" willreturn norecurse\n"
       "define void @test(i32* %P, i32* %P1, i32* %P2, i32* %P3) {\n";
   StringRef Tail = "ret void\n"