code review feedback - use std::optional, renames

Author: hekota

llvm/include/llvm/Analysis/DXILResource.h

@@ -633,7 +633,7 @@ class DXILResourceBindingInfo {
       FreeRanges.emplace_back(0, UINT32_MAX);
     }
     // Size == -1 means unbounded array
-    bool findAvailableBinding(int32_t Size, uint32_t *RegSlot);
+    std::optional<uint32_t> findAvailableBinding(int32_t Size);
   };
 
   struct BindingSpaces {
@@ -678,8 +678,8 @@ class DXILResourceBindingInfo {
   }
 
   // Size == -1 means unbounded array
-  bool findAvailableBinding(dxil::ResourceClass RC, uint32_t Space,
-                            int32_t Size, uint32_t *RegSlot);
+  std::optional<uint32_t> findAvailableBinding(dxil::ResourceClass RC,
+                                               uint32_t Space, int32_t Size);
 
   friend class DXILResourceBindingAnalysis;
   friend class DXILResourceBindingWrapperPass;

llvm/lib/Analysis/DXILResource.cpp

@@ -995,12 +995,12 @@ void DXILResourceBindingInfo::populate(Module &M, DXILResourceTypeMap &DRTM) {
 }
 
 // returns false if binding could not be found in given space
-bool DXILResourceBindingInfo::findAvailableBinding(dxil::ResourceClass RC,
-                                                   uint32_t Space, int32_t Size,
-                                                   uint32_t *RegSlot) {
+std::optional<uint32_t>
+DXILResourceBindingInfo::findAvailableBinding(dxil::ResourceClass RC,
+                                              uint32_t Space, int32_t Size) {
   BindingSpaces &BS = getBindingSpaces(RC);
   RegisterSpace &RS = BS.getOrInsertSpace(Space);
-  return RS.findAvailableBinding(Size, RegSlot);
+  return RS.findAvailableBinding(Size);
 }
 
 DXILResourceBindingInfo::RegisterSpace &
@@ -1015,38 +1015,38 @@ DXILResourceBindingInfo::BindingSpaces::getOrInsertSpace(uint32_t Space) {
   return Spaces.emplace_back(Space);
 }
 
-bool DXILResourceBindingInfo::RegisterSpace::findAvailableBinding(
-    int32_t Size, uint32_t *RegSlot) {
+std::optional<uint32_t>
+DXILResourceBindingInfo::RegisterSpace::findAvailableBinding(int32_t Size) {
   assert((Size == -1 || Size > 0) && "invalid size");
 
+  std::optional<uint32_t> RegSlot;
   if (FreeRanges.empty())
-    return false;
+    return RegSlot;
 
   // unbounded array
   if (Size == -1) {
     BindingRange &Last = FreeRanges.back();
     if (Last.UpperBound != UINT32_MAX)
       // this space is already occupied by an unbounded array
       return false;
-    *RegSlot = Last.LowerBound;
+    RegSlot = Last.LowerBound;
     FreeRanges.pop_back();
-    return true;
-  }
-
-  // single resource or fixed-size array
-  for (BindingRange &R : FreeRanges) {
-    // compare the size as uint64_t to prevent overflow for range (0,
-    // UINT32_MAX)
-    if ((uint64_t)R.UpperBound - R.LowerBound + 1 < (uint64_t)Size)
-      continue;
-    *RegSlot = R.LowerBound;
-    // This might create a range where (LowerBound == UpperBound + 1), but
-    // that's ok.
-    R.LowerBound += Size;
-    return true;
+  } else {
+    // single resource or fixed-size array
+    for (BindingRange &R : FreeRanges) {
+      // compare the size as uint64_t to prevent overflow for range (0,
+      // UINT32_MAX)
+      if ((uint64_t)R.UpperBound - R.LowerBound + 1 < (uint64_t)Size)
+        continue;
+      RegSlot = R.LowerBound;
+      // This might create a range where (LowerBound == UpperBound + 1). When
+      // that happens, the next time this function is called the range will
+      // skipped over by the check above (at this point Size is always > 0).
+      R.LowerBound += Size;
+      break;
+    }
   }
-
-  return false;
+  return RegSlot;
 }
 
 //===----------------------------------------------------------------------===//

llvm/lib/Target/DirectX/DXILResourceImplicitBinding.cpp

@@ -40,13 +40,13 @@ static void diagnoseImplicitBindingNotFound(CallInst *ImplBindingCall) {
 
 static bool assignBindings(Module &M, DXILResourceBindingInfo &DRBI,
                            DXILResourceTypeMap &DRTM) {
-  struct ImplBindingCall {
+  struct ImplicitBindingCall {
     int OrderID;
     CallInst *Call;
-    ImplBindingCall(int OrderID, CallInst *Call)
+    ImplicitBindingCall(int OrderID, CallInst *Call)
         : OrderID(OrderID), Call(Call) {}
   };
-  SmallVector<ImplBindingCall> Calls;
+  SmallVector<ImplicitBindingCall> Calls;
   SmallVector<Function *> FunctionsToMaybeRemove;
 
   // collect all of the llvm.dx.resource.handlefromImplicitbinding calls
@@ -78,7 +78,7 @@ static bool assignBindings(Module &M, DXILResourceBindingInfo &DRBI,
   bool AllBindingsAssigned = true;
   bool Changed = false;
 
-  for (auto &IB : Calls) {
+  for (ImplicitBindingCall &IB : Calls) {
     IRBuilder<> Builder(IB.Call);
 
     if (IB.OrderID != LastOrderID) {
@@ -91,15 +91,14 @@ static bool assignBindings(Module &M, DXILResourceBindingInfo &DRBI,
       int32_t Size =
           cast<ConstantInt>(IB.Call->getArgOperand(2))->getZExtValue();
 
-      uint32_t RegSlot;
-      RegSlotOp = nullptr;
-      if (!DRBI.findAvailableBinding(RTI.getResourceClass(), Space, Size,
-                                     &RegSlot)) {
+      std::optional<uint32_t> RegSlot =
+          DRBI.findAvailableBinding(RTI.getResourceClass(), Space, Size);
+      if (!RegSlot) {
         diagnoseImplicitBindingNotFound(IB.Call);
         AllBindingsAssigned = false;
         continue;
       }
-      RegSlotOp = ConstantInt::get(Builder.getInt32Ty(), RegSlot);
+      RegSlotOp = ConstantInt::get(Builder.getInt32Ty(), RegSlot.value());
     }
 
     if (!RegSlotOp)