Add LLVM_MARK_AS_BITMASK_ENUM to HoistingKind enum

[xiaoleis]

Summary

This revision adds LLVM_MARK_AS_BITMASK_ENUM to HoistingKind to avoid static_cast when performing bitwise operations.

mlir/include/mlir/Dialect/Bufferization/IR/AllocationOpInterface.h

 #define MLIR_DIALECT_BUFFERIZATION_IR_ALLOCATIONOPINTERFACE_H_
 
 #include "mlir/IR/Builders.h"
 
 namespace mlir {
 // Enum class representing different hoisting kinds for the allocation
 // operation
 enum class HoistingKind : uint8_t {
-  None = 0,      // No hoisting kind selected
-  Loop = 1 << 0, // Indicates loop hoisting kind
-  Block = 1 << 1 // Indicates dominated block hoisting kind
+  None = 0,       // No hoisting kind selected
+  Loop = 1 << 0,  // Indicates loop hoisting kind
+  Block = 1 << 1, // Indicates dominated block hoisting kind
+  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ Block)
 };
 } // namespace mlir
 
 #include "mlir/Dialect/Bufferization/IR/AllocationOpInterface.h.inc"
 
 #endif // MLIR_DIALECT_BUFFERIZATION_IR_ALLOCATIONOPINTERFACE_H_

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

static std::optional<Operation *> buildDealloc(OpBuilder &builder,
     return builder.create<memref::DeallocOp>(alloc.getLoc(), alloc)
         .getOperation();
   }
   static std::optional<Value> buildClone(OpBuilder &builder, Value alloc) {
     return builder.create<bufferization::CloneOp>(alloc.getLoc(), alloc)
         .getResult();
   }
   static ::mlir::HoistingKind getHoistingKind() {
-    return static_cast<HoistingKind>(static_cast<uint8_t>(HoistingKind::Loop) |
-                                     static_cast<uint8_t>(HoistingKind::Block));
+    return HoistingKind::Loop | HoistingKind::Block;
   }
   static ::std::optional<::mlir::Operation *>
   buildPromotedAlloc(OpBuilder &builder, Value alloc) {
     Operation *definingOp = alloc.getDefiningOp();
     return builder.create<memref::AllocaOp>(
         definingOp->getLoc(), cast<MemRefType>(definingOp->getResultTypes()[0]),
         definingOp->getOperands(), definingOp->getAttrs());
   }

mlir/lib/Dialect/Bufferization/Transforms/BufferOptimizations.cpp

 static bool isKnownControlFlowInterface(Operation *op) {
   return isa<LoopLikeOpInterface, RegionBranchOpInterface>(op);
 }
 
 /// Returns true if the given operation implements the AllocationOpInterface
 /// and it supports the dominate block hoisting.
 static bool allowAllocDominateBlockHoisting(Operation *op) {
   auto allocOp = dyn_cast<AllocationOpInterface>(op);
-  return allocOp && (static_cast<uint8_t>(allocOp.getHoistingKind()) &
-                     static_cast<uint8_t>(HoistingKind::Block));
+  return allocOp &&
+         static_cast<uint8_t>(allocOp.getHoistingKind() & HoistingKind::Block);
 }
 
 /// Returns true if the given operation implements the AllocationOpInterface
 /// and it supports the loop hoisting.
 static bool allowAllocLoopHoisting(Operation *op) {
   auto allocOp = dyn_cast<AllocationOpInterface>(op);
-  return allocOp && (static_cast<uint8_t>(allocOp.getHoistingKind()) &
-                     static_cast<uint8_t>(HoistingKind::Loop));
+  return allocOp &&
+         static_cast<uint8_t>(allocOp.getHoistingKind() & HoistingKind::Loop);
 }
 
 /// Check if the size of the allocation is less than the given size. The
 /// transformation is only applied to small buffers since large buffers could
 /// exceed the stack space.
 static bool defaultIsSmallAlloc(Value alloc, unsigned maximumSizeInBytes,
                                 unsigned maxRankOfAllocatedMemRef) {
   auto type = dyn_cast<ShapedType>(alloc.getType());