[LangRef] vscale_range implies the vscale is power-of-two

[Allen]

Summary

According the discuss on D154953, we need to make the LangRef change
before the optimization relied on the new behaviour:

    vscale_range implies vscale is a power-of-two value, parse of the
attribute to reject values that are not a power-of-two.

[nikic]

To provide a bit more context here. We would like to have power of two vscale exposed in a target-independent way, so we can make use of this in places like ValueTracking, just like we currently do the vscale range. Some options that have been discussed are:

• Remove support for non-power-of-two vscales entirely. (This is my personal preference, but this is hard to undo if it turns out someone does need them.)
• Add an extra attribute vscale_pow2, or a data layout property.
• Make vscale_range imply power-of-two vscale, as a compromise solution (what this patch does). This would be relatively easy to turn into one of the two above at a later point.

llvm/docs/BitCodeFormat.rst

1095

This change does not affect the bitcode format, no need to modify this file.

llvm/docs/LangRef.rst

2340

This just restricts the min and max. You need to specify that vscale itself is a power of two if the attribute is specified.

[efriedma]

The approach taken here seems fine. It gives the optimization opportunities we want now, but leaves open an escape hatch for non-power-of-two widths if some target does end up needing them. (SVE does require power-of-two lengths, but they made that decision very late; there seems to be some room for other architectures to make a different choice.)

[Allen]

Address comments

[Allen]

llvm/docs/BitCodeFormat.rst

1095

reverted, thanks

llvm/docs/LangRef.rst

2340

Apply your comment, thanks

[paulwalker-arm]

I've offered some alternate phrasing to consider but am happy to accept the patch on principle. Please give others a chance to comment on your final choice of phrasing before landing the patch.

llvm/docs/LangRef.rst

2335–2340

I'd prefer a more unified description. What about:

This function attribute indicates `vscale` is a power-of-two within a specified range. `min` must be a power-of-two that is greater than 0. When specified, `max` must be a power-of-two greater-than-or-equal to `min` or 0 to signify an unbounded maximum. The syntax `vscale_range(<val>)` can be used to set both `min` and `max` to the same value. Functions that don't include this attribute make no assumptions about the value of `vscale`.

[Allen]

Thanks, apply your comment , and I'll wait a couple days before landing this patch.

[nikic]

LGTM

llvm/docs/BitCodeFormat.rst

   arguments, which are 32-bit integers, are packed into one 64-bit integer value
   (i.e. ``(EltSizeParam << 32) | NumEltsParam``), with ``NumEltsParam`` taking on
   the sentinel value -1 if it is not specified.
 
 .. note::
   The ``vscale_range`` attribute has a special encoding for its arguments. Its two
   arguments, which are 32-bit integers, are packed into one 64-bit integer value
   (i.e. ``(Min << 32) | Max``), with ``Max`` taking on the value of ``Min`` if
-  it is not specified.
+  it is not specified. The definition of ``vscale_range`` implies the ``vscale``
+  is power-of-two value.
 
 .. _TYPE_BLOCK:
 
 TYPE_BLOCK Contents
 -------------------
 
 The ``TYPE_BLOCK`` block (id 17) contains records which constitute a table of
 type operator entries used to represent types referenced within an LLVM

llvm/docs/LangRef.rst

     sites within the function. Note that `willreturn` implies `mustprogress`.
 ``"warn-stack-size"="<threshold>"``
     This attribute sets a threshold to emit diagnostics once the frame size is
     known should the frame size exceed the specified value.  It takes one
     required integer value, which should be a non-negative integer, and less
     than `UINT_MAX`.  It's unspecified which threshold will be used when
     duplicate definitions are linked together with differing values.
 ``vscale_range(<min>[, <max>])``
     This attribute indicates the minimum and maximum vscale value for the given
     function. The min must be greater than 0. A maximum value of 0 means
     unbounded. If the optional max value is omitted then max is set to the
     value of min. If the attribute is not present, no assumptions are made
-    about the range of vscale.
+    about the range of vscale. The values of min and max are power-of-two
+    value if the attribute is present.
 ``"nooutline"``
     This attribute indicates that outlining passes should not modify the
     function.
 
 Call Site Attributes
 ----------------------
 
 In addition to function attributes the following call site only

llvm/lib/IR/Verifier.cpp

     if ((K & ZeroedUninit) == ZeroedUninit)
       CheckFailed("'allockind()' can't be both zeroed and uninitialized");
   }
 
   if (Attrs.hasFnAttr(Attribute::VScaleRange)) {
     unsigned VScaleMin = Attrs.getFnAttrs().getVScaleRangeMin();
     if (VScaleMin == 0)
       CheckFailed("'vscale_range' minimum must be greater than 0", V);
-
+    else if (!isPowerOf2_32(VScaleMin))
+      CheckFailed("'vscale_range' minimum must be power-of-two value", V);
     std::optional<unsigned> VScaleMax = Attrs.getFnAttrs().getVScaleRangeMax();
     if (VScaleMax && VScaleMin > VScaleMax)
       CheckFailed("'vscale_range' minimum cannot be greater than maximum", V);
+    else if (VScaleMax && !isPowerOf2_32(*VScaleMax))
+      CheckFailed("'vscale_range' maximum must be power-of-two value", V);
   }
 
   if (Attrs.hasFnAttr("frame-pointer")) {
     StringRef FP = Attrs.getFnAttr("frame-pointer").getValueAsString();
     if (FP != "all" && FP != "non-leaf" && FP != "none")
       CheckFailed("invalid value for 'frame-pointer' attribute: " + FP, V);
   }
 

llvm/test/Transforms/InstCombine/icmp-vscale.ll

 ;
 entry:
   %vscale = call i64 @llvm.vscale.i64()
   %num_els = mul i64 %vscale, 32
   %res = icmp ne i64 %num_els, 39488
   ret i1 %res
 }
 
-define i1 @vscale_ule_max() vscale_range(5,10) {
+define i1 @vscale_ule_max() vscale_range(4,8) {
 ; CHECK-LABEL: @vscale_ule_max(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i16 @llvm.vscale.i16()
-  %res = icmp ule i16 %vscale, 10
+  %res = icmp ule i16 %vscale, 8
   ret i1 %res
 }
 
-define i1 @vscale_ult_max() vscale_range(5,10) {
+define i1 @vscale_ult_max() vscale_range(4,8) {
 ; CHECK-LABEL: @vscale_ult_max(
 ; CHECK-NEXT:    [[VSCALE:%.*]] = call i16 @llvm.vscale.i16()
-; CHECK-NEXT:    [[RES:%.*]] = icmp ult i16 [[VSCALE]], 10
+; CHECK-NEXT:    [[RES:%.*]] = icmp ult i16 [[VSCALE]], 8
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
   %vscale = call i16 @llvm.vscale.i16()
-  %res = icmp ult i16 %vscale, 10
+  %res = icmp ult i16 %vscale, 8
   ret i1 %res
 }
 
-define i1 @vscale_uge_min() vscale_range(5,10) {
+define i1 @vscale_uge_min() vscale_range(4,8) {
 ; CHECK-LABEL: @vscale_uge_min(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i16 @llvm.vscale.i16()
-  %res = icmp uge i16 %vscale, 5
+  %res = icmp uge i16 %vscale, 4
   ret i1 %res
 }
 
-define i1 @vscale_ugt_min() vscale_range(5,10) {
+define i1 @vscale_ugt_min() vscale_range(4,8) {
 ; CHECK-LABEL: @vscale_ugt_min(
 ; CHECK-NEXT:    [[VSCALE:%.*]] = call i16 @llvm.vscale.i16()
-; CHECK-NEXT:    [[RES:%.*]] = icmp ugt i16 [[VSCALE]], 5
+; CHECK-NEXT:    [[RES:%.*]] = icmp ugt i16 [[VSCALE]], 4
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
   %vscale = call i16 @llvm.vscale.i16()
-  %res = icmp ugt i16 %vscale, 5
+  %res = icmp ugt i16 %vscale, 4
   ret i1 %res
 }
 
-define i1 @vscale_uge_no_max() vscale_range(5) {
+define i1 @vscale_uge_no_max() vscale_range(4) {
 ; CHECK-LABEL: @vscale_uge_no_max(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i8 @llvm.vscale.i8()
-  %res = icmp uge i8 %vscale, 5
+  %res = icmp uge i8 %vscale, 4
   ret i1 %res
 }
 
-define i1 @vscale_ugt_no_max() vscale_range(5) {
+define i1 @vscale_ugt_no_max() vscale_range(4) {
 ; CHECK-LABEL: @vscale_ugt_no_max(
 ; CHECK-NEXT:    ret i1 false
 ;
   %vscale = call i8 @llvm.vscale.i8()
-  %res = icmp ugt i8 %vscale, 5
+  %res = icmp ugt i8 %vscale, 4
   ret i1 %res
 }
 
-define i1 @vscale_uge_max_overflow() vscale_range(5,256) {
+define i1 @vscale_uge_max_overflow() vscale_range(4,256) {
 ; CHECK-LABEL: @vscale_uge_max_overflow(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i8 @llvm.vscale.i8()
-  %res = icmp uge i8 %vscale, 5
+  %res = icmp uge i8 %vscale, 4
   ret i1 %res
 }
 
-define i1 @vscale_ugt_max_overflow() vscale_range(5,256) {
+define i1 @vscale_ugt_max_overflow() vscale_range(4,256) {
 ; CHECK-LABEL: @vscale_ugt_max_overflow(
 ; CHECK-NEXT:    [[VSCALE:%.*]] = call i8 @llvm.vscale.i8()
-; CHECK-NEXT:    [[RES:%.*]] = icmp ugt i8 [[VSCALE]], 5
+; CHECK-NEXT:    [[RES:%.*]] = icmp ugt i8 [[VSCALE]], 4
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
   %vscale = call i8 @llvm.vscale.i8()
-  %res = icmp ugt i8 %vscale, 5
+  %res = icmp ugt i8 %vscale, 4
   ret i1 %res
 }
 
-define i1 @vscale_eq_min_overflow() vscale_range(256,300) {
+define i1 @vscale_eq_min_overflow() vscale_range(256,512) {
 ; CHECK-LABEL: @vscale_eq_min_overflow(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i8 @llvm.vscale.i8()
   %res = icmp eq i8 %vscale, 42
   ret i1 %res
 }
 
-define i1 @vscale_ult_min_overflow() vscale_range(256,300) {
+define i1 @vscale_ult_min_overflow() vscale_range(256,512) {
 ; CHECK-LABEL: @vscale_ult_min_overflow(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i8 @llvm.vscale.i8()
   %res = icmp ult i8 %vscale, 42
   ret i1 %res
 }
 
-define i1 @vscale_ugt_min_overflow() vscale_range(256,300) {
+define i1 @vscale_ugt_min_overflow() vscale_range(256,512) {
 ; CHECK-LABEL: @vscale_ugt_min_overflow(
 ; CHECK-NEXT:    ret i1 true
 ;
   %vscale = call i8 @llvm.vscale.i8()
   %res = icmp ugt i8 %vscale, 42
   ret i1 %res
 }
 
 declare i8 @llvm.vscale.i8()
 declare i16 @llvm.vscale.i16()
 declare i32 @llvm.vscale.i32()
 declare i64 @llvm.vscale.i64()

llvm/test/Transforms/InstCombine/vscale_sext_and_zext.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 ;
 ; Sign-extend
 ;
 
-define i32 @vscale_SExt_i8toi32() vscale_range(1, 127) {
+define i32 @vscale_SExt_i8toi32() vscale_range(1, 64) {
 ; CHECK-LABEL: @vscale_SExt_i8toi32(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = call i32 @llvm.vscale.i32()
 ; CHECK-NEXT:    ret i32 [[TMP0]]
 ;
 entry:
   %0 = call i8 @llvm.vscale.i8()
   %1 = sext i8 %0 to i32

llvm/test/Transforms/InstCombine/vscale_trunc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
-define i8 @vscale_trunc_i32toi8() vscale_range(1, 255) {
+define i8 @vscale_trunc_i32toi8() vscale_range(1, 128) {
 ; CHECK-LABEL: @vscale_trunc_i32toi8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = call i8 @llvm.vscale.i8()
 ; CHECK-NEXT:    ret i8 [[TMP0]]
 ;
 entry:
   %0 = call i32 @llvm.vscale.i32()
   %1 = trunc i32 %0 to i8

llvm/test/Verifier/vscale_range.ll

 ; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
 
 ; CHECK: 'vscale_range' minimum must be greater than 0
 declare ptr @a(ptr) vscale_range(0, 1)
 
 ; CHECK: 'vscale_range' minimum cannot be greater than maximum
 declare ptr @b(ptr) vscale_range(8, 1)
+
+; CHECK: 'vscale_range' minimum must be power-of-two value
+declare ptr @c(ptr) vscale_range(3, 16)
+
+; CHECK: 'vscale_range' maximum must be power-of-two value
+declare ptr @d(ptr) vscale_range(2, 5)