Modified assume_alignment description

Changed assertion to assumption and improved description of poison

Author: Shay Kleiman

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

@@ -144,25 +144,21 @@ class AllocLikeOp<string mnemonic,
 
 def AssumeAlignmentOp : MemRef_Op<"assume_alignment", [
       DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-      Pure, 
+      Pure,
       ViewLikeOpInterface,
       SameOperandsAndResultType
     ]> {
   let summary =
-      "assertion that gives alignment information to the input memref";
+      "assumption that gives alignment information to the input memref";
   let description = [{
-      The `assume_alignment` operation takes a memref and an integer of alignment
+      The `assume_alignment` operation takes a memref and an integer alignment
       value. It returns a new SSA value of the same memref type, but associated
-      with the assertion that the underlying buffer is aligned to the given
+      with the assumption that the underlying buffer is aligned to the given
       alignment. 
 
-      If the buffer isn't aligned to the given alignment, this operation
-      itself does not cause undefined behavior. However, subsequent operations
-      that consume the resulting memref and rely on this asserted alignment for
-      correctness will produce a poison value if the assertion is false.
-
+      If the buffer isn't aligned to the given alignment, its result is poison.
       This operation doesn't affect the semantics of a program where the
-      alignment assertion holds true. It is intended for optimization purposes,
+      alignment assumption holds true. It is intended for optimization purposes,
       allowing the compiler to generate more efficient code based on the
       alignment assumption. The optimization is best-effort.
   }];

mlir/lib/Dialect/GPU/Transforms/EliminateBarriers.cpp

@@ -44,8 +44,6 @@ using namespace mlir::gpu;
 // The functions below provide interface-like verification, but are too specific
 // to barrier elimination to become interfaces.
 
-
-
 /// Returns `true` if the op is defines the parallel region that is subject to
 /// barrier synchronization.
 static bool isParallelRegionBoundary(Operation *op) {
@@ -96,7 +94,6 @@ collectEffects(Operation *op,
   if (ignoreBarriers && isa<BarrierOp>(op))
     return true;
 
-
   // Collect effect instances the operation. Note that the implementation of
   // getEffects erases all effect instances that have the type other than the
   // template parameter so we collect them first in a local buffer and then

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

@@ -527,7 +527,8 @@ LogicalResult AssumeAlignmentOp::verify() {
   return success();
 }
 
-void AssumeAlignmentOp::getAsmResultNames(function_ref<void(Value, StringRef)> setNameFn) {
+void AssumeAlignmentOp::getAsmResultNames(
+    function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "assume_align");
 }
 

mlir/lib/Dialect/MemRef/Transforms/ExpandStridedMetadata.cpp

@@ -937,12 +937,13 @@ struct ExtractStridedMetadataOpAssumeAlignmentFolder
 
   LogicalResult matchAndRewrite(memref::ExtractStridedMetadataOp op,
                                 PatternRewriter &rewriter) const override {
-    auto assumeAlignmentOp = 
+    auto assumeAlignmentOp =
         op.getSource().getDefiningOp<memref::AssumeAlignmentOp>();
     if (!assumeAlignmentOp)
       return failure();
 
-    rewriter.replaceOpWithNewOp<memref::ExtractStridedMetadataOp>(op, assumeAlignmentOp.getViewSource());
+    rewriter.replaceOpWithNewOp<memref::ExtractStridedMetadataOp>(
+        op, assumeAlignmentOp.getViewSource());
     return success();
   }
 };