Change Attribute::get to consider 0 value as IntValue

[anna]

Summary

Alternate approach to D124115. I honestly prefer D124115, but placing
this here to show the alternate way involving fixing locations where we
consider zero value for enum attributes. Note that without the change in
Transforms/IPO/Attributor.cpp, this change fails for the test
test/Transforms/Attributor/nonnull.ll.
There are couple of other failures as well, I just fixed this
Attributor.cpp, but we will need to do the same for other usages where
we make this assumption (enum attribute can contain zero value passed
in).

The benefit of this approach is that it makes the Attribute::get API
clearer and callers will need to honour the API.

llvm/include/llvm/IR/Attributes.h

 public:
   Attribute() = default;
 
   //===--------------------------------------------------------------------===//
   // Attribute Construction
   //===--------------------------------------------------------------------===//
 
   /// Return a uniquified Attribute object.
-  static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
+  static Attribute get(LLVMContext &Context, AttrKind Kind,
+                       Optional<uint64_t> Val = NoneType::None);
   static Attribute get(LLVMContext &Context, StringRef Kind,
                        StringRef Val = StringRef());
   static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty);
 
   /// Return a uniquified Attribute object that has the specific
   /// alignment set.
   static Attribute getWithAlignment(LLVMContext &Context, Align Alignment);
   static Attribute getWithStackAlignment(LLVMContext &Context, Align Alignment);

llvm/lib/IR/Attributes.cpp

unpackVScaleRangeArgs(uint64_t Value) {
   unsigned MaxValue = Value & std::numeric_limits<unsigned>::max();
   unsigned MinValue = Value >> 32;
 
   return std::make_pair(MinValue,
                         MaxValue > 0 ? MaxValue : Optional<unsigned>());
 }
 
 Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
-                         uint64_t Val) {
+                         Optional<uint64_t> Val) {
   if (Val)
     assert(Attribute::isIntAttrKind(Kind) && "Not an int attribute");
   else
     assert(Attribute::isEnumAttrKind(Kind) && "Not an enum attribute");
 
   LLVMContextImpl *pImpl = Context.pImpl;
   FoldingSetNodeID ID;
   ID.AddInteger(Kind);
-  if (Val) ID.AddInteger(Val);
+  if (Val.hasValue()) ID.AddInteger(*Val);
 
   void *InsertPoint;
   AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
 
   if (!PA) {
     // If we didn't find any existing attributes of the same shape then create a
     // new one and insert it.
-    if (!Val)
+    if (!Val.hasValue())
       PA = new (pImpl->Alloc) EnumAttributeImpl(Kind);
     else
-      PA = new (pImpl->Alloc) IntAttributeImpl(Kind, Val);
+      PA = new (pImpl->Alloc) IntAttributeImpl(Kind, *Val);
     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
   }
 
   // Return the Attribute that we found or created.
   return Attribute(PA);
 }
 
 Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {

llvm/lib/Transforms/IPO/Attributor.cpp

if (A2K.empty())
     return false;
 
   LLVMContext &Ctx = AssociatedValue.getContext();
   unsigned AttrsSize = Attrs.size();
   MustBeExecutedContextExplorer &Explorer =
       A.getInfoCache().getMustBeExecutedContextExplorer();
   auto EIt = Explorer.begin(getCtxI()), EEnd = Explorer.end(getCtxI());
   for (auto &It : A2K)
-    if (Explorer.findInContextOf(It.first, EIt, EEnd))
-      Attrs.push_back(Attribute::get(Ctx, AK, It.second.Max));
+    if (Explorer.findInContextOf(It.first, EIt, EEnd)) {
+      auto OptVal = It.second.Max == 0 ? None : Optional<uint64_t>(It.second.Max);
+      Attrs.push_back(Attribute::get(Ctx, AK, OptVal));
+    }
   return AttrsSize != Attrs.size();
 }
 
 void IRPosition::verify() {
 #ifdef EXPENSIVE_CHECKS
   switch (getPositionKind()) {
   case IRP_INVALID:
     assert((CBContext == nullptr) &&