[AssumeBundles] filter usefull attriutes to preserve

[Tyker]

Summary

This patch will filter attributes to only preserve those that are usefull.
In the case of NoAlias it is filtered out not because it isn't usefull
but because it is incorrect to preserve it as it is only valdi for the
duration of the function.

[jdoerfert]

llvm/lib/IR/KnowledgeRetention.cpp

109

Are we sure we want to keep a positive list of useful ones? (Instead of a negative list of not-useful ones?)

[Tyker]

llvm/lib/IR/KnowledgeRetention.cpp

109

i looked at all attributes we support and most of them aren't useful. so i think the list is shorter this way and will need less updating.

but perhaps a negative pattern has a better default.

[jdoerfert]

LGTM.

llvm/lib/IR/KnowledgeRetention.cpp

109

Let's keep it for now, but at the latest once we have assume ranges it will probably be easier to keep them and opt-out.

llvm/lib/IR/KnowledgeRetention.cpp

return std::make_tuple(
                   ->getZExtValue(),
          Op.input_size() <= BOIE_WasOn
             ? StringRef("")
             : (*(Op.input_begin() + BOIE_WasOn))->getName());
   };
   return getTuple(LHS) < getTuple(RHS);
 }
 
+bool isUsefullToPreserve(Attribute::AttrKind Kind) {
+  switch (Kind) {
+    case Attribute::NonNull:
+    case Attribute::Alignment:
+    case Attribute::Dereferenceable:
+    case Attribute::DereferenceableOrNull:
+    case Attribute::Cold:
+      return true;
+    default:
+      return false;
+  }
+}
+
 /// This class contain all knowledge that have been gather while building an
 /// llvm.assume and the function to manipulate it.
 struct AssumeBuilderState {
   Module *M;
 
   SmallDenseSet<AssumedKnowledge, 8> AssumedKnowledgeSet;
 
   AssumeBuilderState(Module *M) : M(M) {}
 
   void addAttribute(Attribute Attr, Value *WasOn) {
+    if (!ShouldPreserveAllAttributes &&
+        (Attr.isTypeAttribute() || Attr.isStringAttribute() ||
+         !isUsefullToPreserve(Attr.getKindAsEnum())))
+      return;
     StringRef Name;
     Value *AttrArg = nullptr;
     if (Attr.isStringAttribute())
-      if (ShouldPreserveAllAttributes)
-        Name = Attr.getKindAsString();
-      else
-        return;
-    else
       Name = Attribute::getNameFromAttrKind(Attr.getKindAsEnum());
     if (Attr.isIntAttribute())
       AttrArg = ConstantInt::get(Type::getInt64Ty(M->getContext()),
                                  Attr.getValueAsInt());
     AssumedKnowledgeSet.insert(
         {Name.data(), AttrArg, {WasOn, AssumedKnowledge::None}});
   }
 
   void addCall(const CallBase *Call) {
     auto addAttrList = [&](AttributeList AttrList) {
       for (unsigned Idx = AttributeList::FirstArgIndex;
            Idx < AttrList.getNumAttrSets(); Idx++)
         for (Attribute Attr : AttrList.getAttributes(Idx))
           addAttribute(Attr, Call->getArgOperand(Idx - 1));
-      if (ShouldPreserveAllAttributes)
-        for (Attribute Attr : AttrList.getFnAttributes())
-          addAttribute(Attr, nullptr);
     };
     addAttrList(Call->getAttributes());
     if (Function *Fn = Call->getCalledFunction())
       addAttrList(Fn->getAttributes());
   }
 
   CallInst *build() {
     if (AssumedKnowledgeSet.empty())

llvm/test/IR/assume-builder.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; 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) {
 ; BASIC-LABEL: @test(
 ; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[P:%.*]], i64 16), "nonnull"(i32* [[P]]) ]
 ; BASIC-NEXT:    call void @func(i32* nonnull dereferenceable(16) [[P]], i32* null)
 ; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[P1:%.*]], i64 12), "nonnull"(i32* [[P]]) ]
 ; BASIC-NEXT:    call void @func(i32* dereferenceable(12) [[P1]], i32* nonnull [[P]])
-; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[P1]], i64 12) ]
+; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "cold"(), "dereferenceable"(i32* [[P1]], i64 12) ]
 ; BASIC-NEXT:    call void @func_cold(i32* dereferenceable(12) [[P1]]) #0
-; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[P1]], i64 12) ]
+; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "cold"(), "dereferenceable"(i32* [[P1]], i64 12) ]
 ; BASIC-NEXT:    call void @func_cold(i32* dereferenceable(12) [[P1]])
 ; BASIC-NEXT:    call void @func(i32* [[P1]], i32* [[P]])
 ; BASIC-NEXT:    call void @func_strbool(i32* [[P1]])
 ; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[P]], i64 8), "dereferenceable"(i32* [[P]], i64 16) ]
 ; BASIC-NEXT:    call void @func(i32* dereferenceable(16) [[P]], i32* dereferenceable(8) [[P]])
 ; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[P1]], i64 8) ]
 ; BASIC-NEXT:    call void @func_many(i32* align 8 [[P1]])
 ; BASIC-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[P2:%.*]], i64 8), "nonnull"(i32* [[P3:%.*]]) ]

llvm/test/Transforms/Inline/noalias2.ll

 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 {
-; NO_ASSUME-LABEL: define {{[^@]+}}@foo
-; NO_ASSUME-SAME: (float* noalias nocapture [[A:%.*]], float* noalias nocapture readonly [[C:%.*]]) #0
-; NO_ASSUME-NEXT:  entry:
-; NO_ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !0, !noalias !3
-; NO_ASSUME-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
-; NO_ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !3, !noalias !0
-; NO_ASSUME-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
-; NO_ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; NO_ASSUME-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
-; NO_ASSUME-NEXT:    ret void
-;
-; USE_ASSUME-LABEL: define {{[^@]+}}@foo
-; USE_ASSUME-SAME: (float* noalias nocapture [[A:%.*]], float* noalias nocapture readonly [[C:%.*]]) #0
-; USE_ASSUME-NEXT:  entry:
-; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "noalias"(float* [[A]]), "noalias"(float* [[C]]), "nocapture"(float* [[A]]), "nocapture"(float* [[C]]), "readonly"(float* [[C]]) ]
-; USE_ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !0, !noalias !3
-; USE_ASSUME-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
-; USE_ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I]], align 4, !alias.scope !3, !noalias !0
-; USE_ASSUME-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4
-; USE_ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; USE_ASSUME-NEXT:    store float [[TMP1]], float* [[ARRAYIDX]], align 4
-; USE_ASSUME-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@foo
+; CHECK-SAME: (float* noalias nocapture [[A:%.*]], float* noalias nocapture readonly [[C:%.*]]) #0
+; 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:%.*]]) ]
+; 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
 }
 
entry:
   %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 {
-; NO_ASSUME-LABEL: define {{[^@]+}}@foo2
-; NO_ASSUME-SAME: (float* nocapture [[A:%.*]], float* nocapture [[B:%.*]], float* nocapture readonly [[C:%.*]]) #0
-; NO_ASSUME-NEXT:  entry:
-; NO_ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !5, !noalias !10
-; NO_ASSUME-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
-; NO_ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !10, !noalias !5
-; NO_ASSUME-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !alias.scope !13, !noalias !14
-; NO_ASSUME-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; NO_ASSUME-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !alias.scope !14, !noalias !13
-; NO_ASSUME-NEXT:    [[TMP2:%.*]] = load float, float* [[C]], align 4, !noalias !15
-; NO_ASSUME-NEXT:    [[ARRAYIDX_I1:%.*]] = getelementptr inbounds float, float* [[A]], i64 6
-; NO_ASSUME-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I1]], align 4, !alias.scope !19, !noalias !20
-; NO_ASSUME-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B]], i64 8
-; NO_ASSUME-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !20, !noalias !19
-; NO_ASSUME-NEXT:    [[TMP3:%.*]] = load float, float* [[C]], align 4
-; NO_ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; NO_ASSUME-NEXT:    store float [[TMP3]], float* [[ARRAYIDX]], align 4
-; NO_ASSUME-NEXT:    ret void
-;
-; USE_ASSUME-LABEL: define {{[^@]+}}@foo2
-; USE_ASSUME-SAME: (float* nocapture [[A:%.*]], float* nocapture [[B:%.*]], float* nocapture readonly [[C:%.*]]) #0
-; USE_ASSUME-NEXT:  entry:
-; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "noalias"(float* [[A]]), "noalias"(float* [[C]]), "nocapture"(float* [[A]]), "nocapture"(float* [[C]]), "readonly"(float* [[C]]) ]
-; USE_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
-; USE_ASSUME-NEXT:    [[TMP0:%.*]] = load float, float* [[C]], align 4, !alias.scope !9, !noalias !12
-; USE_ASSUME-NEXT:    [[ARRAYIDX_I_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 5
-; USE_ASSUME-NEXT:    store float [[TMP0]], float* [[ARRAYIDX_I_I]], align 4, !alias.scope !12, !noalias !9
-; USE_ASSUME-NEXT:    [[TMP1:%.*]] = load float, float* [[C]], align 4, !alias.scope !14, !noalias !15
-; USE_ASSUME-NEXT:    [[ARRAYIDX_I:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; USE_ASSUME-NEXT:    store float [[TMP1]], float* [[ARRAYIDX_I]], align 4, !alias.scope !15, !noalias !14
-; USE_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]]) ]
-; USE_ASSUME-NEXT:    [[TMP2:%.*]] = load float, float* [[C]], align 4, !noalias !16
-; USE_ASSUME-NEXT:    [[ARRAYIDX_I1:%.*]] = getelementptr inbounds float, float* [[A]], i64 6
-; USE_ASSUME-NEXT:    store float [[TMP2]], float* [[ARRAYIDX_I1]], align 4, !alias.scope !20, !noalias !21
-; USE_ASSUME-NEXT:    [[ARRAYIDX1_I:%.*]] = getelementptr inbounds float, float* [[B]], i64 8
-; USE_ASSUME-NEXT:    store float [[TMP2]], float* [[ARRAYIDX1_I]], align 4, !alias.scope !21, !noalias !20
-; USE_ASSUME-NEXT:    [[TMP3:%.*]] = load float, float* [[C]], align 4
-; USE_ASSUME-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, float* [[A]], i64 7
-; USE_ASSUME-NEXT:    store float [[TMP3]], float* [[ARRAYIDX]], align 4
-; USE_ASSUME-NEXT:    ret void
+; CHECK-LABEL: define {{[^@]+}}@foo2
+; CHECK-SAME: (float* nocapture [[A:%.*]], float* nocapture [[B:%.*]], float* nocapture readonly [[C:%.*]]) #0
+; 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
 ;
 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

llvm/unittests/IR/KnowledgeRetentionTest.cpp

for (auto &Elem : Tests) {
     SMDiagnostic Err;
     std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
     if (!Mod)
       Err.print("AssumeQueryAPI", errs());
     Elem.second(&*(Mod->getFunction("test")->begin()->begin()));
   }
 }
 
-static void AssertMatchesExactlyAttributes(CallInst *Assume, Value *WasOn,
+bool hasMatchesExactlyAttributes(CallInst *Assume, Value *WasOn,
                                     StringRef AttrToMatch) {
   Regex Reg(AttrToMatch);
   SmallVector<StringRef, 1> Matches;
   for (StringRef Attr : {
 #define GET_ATTR_NAMES
 #define ATTRIBUTE_ALL(ENUM_NAME, DISPLAY_NAME) StringRef(#DISPLAY_NAME),
 #include "llvm/IR/Attributes.inc"
        }) {
     bool ShouldHaveAttr = Reg.match(Attr, &Matches) && Matches[0] == Attr;
-    if (ShouldHaveAttr != hasAttributeInAssume(*Assume, WasOn, Attr)) {
-      ASSERT_TRUE(false);
-    }
+    if (ShouldHaveAttr != hasAttributeInAssume(*Assume, WasOn, Attr))
+      return false;
   }
+  return true;
 }
 
-static void AssertHasTheRightValue(CallInst *Assume, Value *WasOn,
+bool hasTheRightValue(CallInst *Assume, Value *WasOn,
                             Attribute::AttrKind Kind, unsigned Value, bool Both,
                             AssumeQuery AQ = AssumeQuery::Highest) {
   if (!Both) {
     uint64_t ArgVal = 0;
-    ASSERT_TRUE(hasAttributeInAssume(*Assume, WasOn, Kind, &ArgVal, AQ));
-    ASSERT_EQ(ArgVal, Value);
-    return;
+    if (!hasAttributeInAssume(*Assume, WasOn, Kind, &ArgVal, AQ))
+      return false;
+    if (ArgVal != Value)
+      return false;
+    return true;
   }
   uint64_t ArgValLow = 0;
   uint64_t ArgValHigh = 0;
   bool ResultLow = hasAttributeInAssume(*Assume, WasOn, Kind, &ArgValLow,
                                         AssumeQuery::Lowest);
   bool ResultHigh = hasAttributeInAssume(*Assume, WasOn, Kind, &ArgValHigh,
                                          AssumeQuery::Highest);
-  if (ResultLow != ResultHigh || ResultHigh == false) {
-    ASSERT_TRUE(false);
-  }
-  if (ArgValLow != Value || ArgValLow != ArgValHigh) {
-    ASSERT_TRUE(false);
-  }
+  if (ResultLow != ResultHigh || ResultHigh == false)
+    return false;
+  if (ArgValLow != Value || ArgValLow != ArgValHigh)
+    return false;
+  return true;
 }
 
 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"
                    "}";
   std::vector<std::pair<StringRef, llvm::function_ref<void(Instruction *)>>>
       Tests;
   Tests.push_back(std::make_pair(
       "call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
       "8 noalias %P1)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(0),
-                                       "(nonnull|align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(1),
-                                       "(noalias|align)");
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Dereferenceable, 16, true);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Alignment, 4, true);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Alignment, 4, true);
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(0),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(1),
+                                       "(align)"));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Dereferenceable, 16, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Alignment, 4, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Alignment, 4, true));
       }));
   Tests.push_back(std::make_pair(
       "call void @func1(i32* nonnull align 32 dereferenceable(48) %P, i32* "
       "nonnull "
       "align 8 dereferenceable(28) %P, i32* nonnull align 64 "
       "dereferenceable(4) "
       "%P, i32* nonnull align 16 dereferenceable(12) %P)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(0),
-                                       "(nonnull|align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(1),
-                                       "(nonnull|align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(2),
-                                       "(nonnull|align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(3),
-                                       "(nonnull|align|dereferenceable)");
-        AssertHasTheRightValue(Assume, I->getOperand(0),
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(0),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(1),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(2),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(3),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
                                Attribute::AttrKind::Dereferenceable, 48, false,
-                               AssumeQuery::Highest);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
+                               AssumeQuery::Highest));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
                                Attribute::AttrKind::Alignment, 64, false,
-                               AssumeQuery::Highest);
-        AssertHasTheRightValue(Assume, I->getOperand(1),
+                               AssumeQuery::Highest));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(1),
                                Attribute::AttrKind::Alignment, 64, false,
-                               AssumeQuery::Highest);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
+                               AssumeQuery::Highest));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
                                Attribute::AttrKind::Dereferenceable, 4, false,
-                               AssumeQuery::Lowest);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
+                               AssumeQuery::Lowest));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
                                Attribute::AttrKind::Alignment, 8, false,
-                               AssumeQuery::Lowest);
-        AssertHasTheRightValue(Assume, I->getOperand(1),
+                               AssumeQuery::Lowest));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(1),
                                Attribute::AttrKind::Alignment, 8, false,
-                               AssumeQuery::Lowest);
+                               AssumeQuery::Lowest));
       }));
   Tests.push_back(std::make_pair(
       "call void @func_many(i32* align 8 %P1) cold\n", [](Instruction *I) {
         ShouldPreserveAllAttributes.setValue(true);
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
-        AssertMatchesExactlyAttributes(
+        ASSERT_TRUE(hasMatchesExactlyAttributes(
             Assume, nullptr,
             "(align|no-jump-tables|less-precise-fpmad|"
-            "nounwind|norecurse|willreturn|cold)");
+            "nounwind|norecurse|willreturn|cold)"));
         ShouldPreserveAllAttributes.setValue(false);
       }));
   Tests.push_back(
       std::make_pair("call void @llvm.assume(i1 true)\n", [](Instruction *I) {
         CallInst *Assume = cast<CallInst>(I);
-        AssertMatchesExactlyAttributes(Assume, nullptr, "");
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, nullptr, ""));
       }));
   Tests.push_back(std::make_pair(
       "call void @func1(i32* readnone align 32 "
       "dereferenceable(48) noalias %P, i32* "
       "align 8 dereferenceable(28) %P1, i32* align 64 "
       "dereferenceable(4) "
       "%P2, i32* nonnull align 16 dereferenceable(12) %P3)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
-        AssertMatchesExactlyAttributes(
+        ASSERT_TRUE(hasMatchesExactlyAttributes(
             Assume, I->getOperand(0),
-            "(readnone|align|dereferenceable|noalias)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(1),
-                                       "(align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(2),
-                                       "(align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(3),
-                                       "(nonnull|align|dereferenceable)");
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Alignment, 32, true);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Dereferenceable, 48, true);
-        AssertHasTheRightValue(Assume, I->getOperand(1),
-                               Attribute::AttrKind::Dereferenceable, 28, true);
-        AssertHasTheRightValue(Assume, I->getOperand(1),
-                               Attribute::AttrKind::Alignment, 8, true);
-        AssertHasTheRightValue(Assume, I->getOperand(2),
-                               Attribute::AttrKind::Alignment, 64, true);
-        AssertHasTheRightValue(Assume, I->getOperand(2),
-                               Attribute::AttrKind::Dereferenceable, 4, true);
-        AssertHasTheRightValue(Assume, I->getOperand(3),
-                               Attribute::AttrKind::Alignment, 16, true);
-        AssertHasTheRightValue(Assume, I->getOperand(3),
-                               Attribute::AttrKind::Dereferenceable, 12, true);
+            "(align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(1),
+                                       "(align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(2),
+                                       "(align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(3),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Alignment, 32, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Dereferenceable, 48, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(1),
+                               Attribute::AttrKind::Dereferenceable, 28, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(1),
+                               Attribute::AttrKind::Alignment, 8, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(2),
+                               Attribute::AttrKind::Alignment, 64, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(2),
+                               Attribute::AttrKind::Dereferenceable, 4, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(3),
+                               Attribute::AttrKind::Alignment, 16, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(3),
+                               Attribute::AttrKind::Dereferenceable, 12, true));
       }));
 
   Tests.push_back(std::make_pair(
       "call void @func1(i32* readnone align 32 "
       "dereferenceable(48) noalias %P, i32* "
       "align 8 dereferenceable(28) %P1, i32* align 64 "
       "dereferenceable(4) "
       "%P2, i32* nonnull align 16 dereferenceable(12) %P3)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
         I->getOperand(1)->dropDroppableUses();
         I->getOperand(2)->dropDroppableUses();
         I->getOperand(3)->dropDroppableUses();
-        AssertMatchesExactlyAttributes(
+        ASSERT_TRUE(hasMatchesExactlyAttributes(
             Assume, I->getOperand(0),
-            "(readnone|align|dereferenceable|noalias)");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(1), "");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(2), "");
-        AssertMatchesExactlyAttributes(Assume, I->getOperand(3), "");
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Alignment, 32, true);
-        AssertHasTheRightValue(Assume, I->getOperand(0),
-                               Attribute::AttrKind::Dereferenceable, 48, true);
+            "(align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(1),
+                                       ""));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(2),
+                                       ""));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, I->getOperand(3),
+                                       ""));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Alignment, 32, true));
+        ASSERT_TRUE(hasTheRightValue(Assume, I->getOperand(0),
+                               Attribute::AttrKind::Dereferenceable, 48, true));
       }));
   Tests.push_back(std::make_pair(
       "call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
       "8 noalias %P1)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
         Value *New = I->getFunction()->getArg(3);
         Value *Old = I->getOperand(0);
-        AssertMatchesExactlyAttributes(Assume, New, "");
-        AssertMatchesExactlyAttributes(Assume, Old,
-                                       "(nonnull|align|dereferenceable)");
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, New, ""));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, Old,
+                                       "(nonnull|align|dereferenceable)"));
         Old->replaceAllUsesWith(New);
-        AssertMatchesExactlyAttributes(Assume, New,
-                                       "(nonnull|align|dereferenceable)");
-        AssertMatchesExactlyAttributes(Assume, Old, "");
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, New,
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(hasMatchesExactlyAttributes(Assume, Old, ""));
       }));
   RunTest(Head, Tail, Tests);
 }
 
-static void AssertFindExactlyAttributes(RetainedKnowledgeMap &Map, Value *WasOn,
+static bool FindExactlyAttributes(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);
-    }
+    if (ShouldHaveAttr != (Map.find(RetainedKnowledgeKey{WasOn, Attribute::getAttrKindFromName(Attr)}) != Map.end()))
+      return false;
   }
+  return true;
 }
 
-static void AssertMapHasRightValue(RetainedKnowledgeMap &Map,
+static bool MapHasRightValue(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);
+  return (LookupIt != Map.end()) && (LookupIt->second.Min == MM.Min) &&
+         (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"
                    "}";
   std::vector<std::pair<StringRef, llvm::function_ref<void(Instruction *)>>>
       Tests;
   Tests.push_back(std::make_pair(
       "call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
       "8 noalias %P1)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
 
         RetainedKnowledgeMap Map;
         fillMapFromAssume(*Assume, Map);
-        AssertFindExactlyAttributes(Map, I->getOperand(0),
-                                       "(nonnull|align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, I->getOperand(1),
-                                       "(noalias|align)");
-        AssertMapHasRightValue(
-            Map, {I->getOperand(0), Attribute::Dereferenceable}, {16, 16});
-        AssertMapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
-                               {4, 4});
-        AssertMapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
-                               {4, 4});
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(0),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(1),
+                                       "(align)"));
+        ASSERT_TRUE(MapHasRightValue(
+            Map, {I->getOperand(0), Attribute::Dereferenceable}, {16, 16}));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
+                               {4, 4}));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
+                               {4, 4}));
       }));
   Tests.push_back(std::make_pair(
       "call void @func1(i32* nonnull align 32 dereferenceable(48) %P, i32* "
       "nonnull "
       "align 8 dereferenceable(28) %P, i32* nonnull align 64 "
       "dereferenceable(4) "
       "%P, i32* nonnull align 16 dereferenceable(12) %P)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
 
         RetainedKnowledgeMap Map;
         fillMapFromAssume(*Assume, Map);
 
-        AssertFindExactlyAttributes(Map, I->getOperand(0),
-                                       "(nonnull|align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, I->getOperand(1),
-                                       "(nonnull|align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, I->getOperand(2),
-                                       "(nonnull|align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, I->getOperand(3),
-                                       "(nonnull|align|dereferenceable)");
-        AssertMapHasRightValue(
-            Map, {I->getOperand(0), Attribute::Dereferenceable}, {4, 48});
-        AssertMapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
-                               {8, 64});
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(0),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(1),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(2),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(3),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(MapHasRightValue(
+            Map, {I->getOperand(0), Attribute::Dereferenceable}, {4, 48}));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
+                               {8, 64}));
       }));
   Tests.push_back(std::make_pair(
       "call void @func_many(i32* align 8 %P1) cold\n", [](Instruction *I) {
         ShouldPreserveAllAttributes.setValue(true);
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
 
         RetainedKnowledgeMap Map;
         fillMapFromAssume(*Assume, Map);
 
-        AssertFindExactlyAttributes(
-            Map, nullptr, "(nounwind|norecurse|willreturn|cold)");
+        ASSERT_TRUE(FindExactlyAttributes(
+            Map, nullptr, "(nounwind|norecurse|willreturn|cold)"));
         ShouldPreserveAllAttributes.setValue(false);
       }));
   Tests.push_back(
       std::make_pair("call void @llvm.assume(i1 true)\n", [](Instruction *I) {
         RetainedKnowledgeMap Map;
         fillMapFromAssume(*cast<CallInst>(I), Map);
 
-        AssertFindExactlyAttributes(Map, nullptr, "");
+        ASSERT_TRUE(FindExactlyAttributes(Map, nullptr, ""));
         ASSERT_TRUE(Map.empty());
       }));
   Tests.push_back(std::make_pair(
       "call void @func1(i32* readnone align 32 "
       "dereferenceable(48) noalias %P, i32* "
       "align 8 dereferenceable(28) %P1, i32* align 64 "
       "dereferenceable(4) "
       "%P2, i32* nonnull align 16 dereferenceable(12) %P3)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
 
         RetainedKnowledgeMap Map;
         fillMapFromAssume(*Assume, Map);
 
-        AssertFindExactlyAttributes(Map, I->getOperand(0),
-                                    "(readnone|align|dereferenceable|noalias)");
-        AssertFindExactlyAttributes(Map, I->getOperand(1),
-                                    "(align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, I->getOperand(2),
-                                       "(align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, I->getOperand(3),
-                                       "(nonnull|align|dereferenceable)");
-        AssertMapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
-                               {32, 32});
-        AssertMapHasRightValue(
-            Map, {I->getOperand(0), Attribute::Dereferenceable}, {48, 48});
-        AssertMapHasRightValue(
-            Map, {I->getOperand(0), Attribute::NoAlias}, {0, 0});
-        AssertMapHasRightValue(
-            Map, {I->getOperand(1), Attribute::Dereferenceable}, {28, 28});
-        AssertMapHasRightValue(Map, {I->getOperand(1), Attribute::Alignment},
-                               {8, 8});
-        AssertMapHasRightValue(Map, {I->getOperand(2), Attribute::Alignment},
-                               {64, 64});
-        AssertMapHasRightValue(
-            Map, {I->getOperand(2), Attribute::Dereferenceable}, {4, 4});
-        AssertMapHasRightValue(Map, {I->getOperand(3), Attribute::Alignment},
-                               {16, 16});
-        AssertMapHasRightValue(
-            Map, {I->getOperand(3), Attribute::Dereferenceable}, {12, 12});
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(0),
+                                    "(align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(1),
+                                    "(align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(2),
+                                       "(align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, I->getOperand(3),
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(0), Attribute::Alignment},
+                               {32, 32}));
+        ASSERT_TRUE(MapHasRightValue(
+            Map, {I->getOperand(0), Attribute::Dereferenceable}, {48, 48}));
+        ASSERT_TRUE(MapHasRightValue(
+            Map, {I->getOperand(1), Attribute::Dereferenceable}, {28, 28}));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(1), Attribute::Alignment},
+                               {8, 8}));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(2), Attribute::Alignment},
+                               {64, 64}));
+        ASSERT_TRUE(MapHasRightValue(
+            Map, {I->getOperand(2), Attribute::Dereferenceable}, {4, 4}));
+        ASSERT_TRUE(MapHasRightValue(Map, {I->getOperand(3), Attribute::Alignment},
+                               {16, 16}));
+        ASSERT_TRUE(MapHasRightValue(
+            Map, {I->getOperand(3), Attribute::Dereferenceable}, {12, 12}));
       }));
 
   /// Keep this test last as it modifies the function.
   Tests.push_back(std::make_pair(
       "call void @func(i32* nonnull align 4 dereferenceable(16) %P, i32* align "
       "8 noalias %P1)\n",
       [](Instruction *I) {
         CallInst *Assume = BuildAssumeFromInst(I);
         Assume->insertBefore(I);
 
         RetainedKnowledgeMap Map;
         fillMapFromAssume(*Assume, Map);
 
         Value *New = I->getFunction()->getArg(3);
         Value *Old = I->getOperand(0);
-        AssertFindExactlyAttributes(Map, New, "");
-        AssertFindExactlyAttributes(Map, Old,
-                                       "(nonnull|align|dereferenceable)");
+        ASSERT_TRUE(FindExactlyAttributes(Map, New, ""));
+        ASSERT_TRUE(FindExactlyAttributes(Map, Old,
+                                       "(nonnull|align|dereferenceable)"));
         Old->replaceAllUsesWith(New);
         Map.clear();
         fillMapFromAssume(*Assume, Map);
-        AssertFindExactlyAttributes(Map, New,
-                                       "(nonnull|align|dereferenceable)");
-        AssertFindExactlyAttributes(Map, Old, "");
+        ASSERT_TRUE(FindExactlyAttributes(Map, New,
+                                       "(nonnull|align|dereferenceable)"));
+        ASSERT_TRUE(FindExactlyAttributes(Map, Old, ""));
       }));
   RunTest(Head, Tail, Tests);
 }
 
 static void RunRandTest(uint64_t Seed, int Size, int MinCount, int MaxCount,
                         unsigned MaxValue) {
   LLVMContext C;
   SMDiagnostic Err;