[SCEV] recognize llvm.annotation intrinsic

[shchenz]

Summary

We use this intrinsic in our codes. With this intrinsic, the consecutive store can not be recognized in SLP vectorizer.

[nikic]

Previous attempt: https://reviews.llvm.org/D102344

The semantics of this intrinsics as specified by LangRef really leave something to be desired. In particular it's not clear to me whether it is okay to replace the llvm.annotation result with its argument during middle-end optimization, because that's what this SCEV change will ultimately lead to (at least in some cases).

[shchenz]

In D127835#3584624, @nikic wrote:

Previous attempt: https://reviews.llvm.org/D102344

The semantics of this intrinsics as specified by LangRef really leave something to be desired. In particular it's not clear to me whether it is okay to replace the llvm.annotation result with its argument during middle-end optimization, because that's what this SCEV change will ultimately lead to (at least in some cases).

From the conclusion of patch D102344, I am thinking there was already an agreement that replacing the llvm.annotation result with its argument during middle-end optimization is valid according to LLVM language reference.

I will ping the patch D102344, thanks for pointing out this patch.

[nikic]

In D127835#3584643, @shchenz wrote:

In D127835#3584624, @nikic wrote:

Previous attempt: https://reviews.llvm.org/D102344

The semantics of this intrinsics as specified by LangRef really leave something to be desired. In particular it's not clear to me whether it is okay to replace the llvm.annotation result with its argument during middle-end optimization, because that's what this SCEV change will ultimately lead to (at least in some cases).

From the conclusion of patch D102344, I am thinking there was already an agreement that replacing the llvm.annotation result with its argument during middle-end optimization is valid according to LLVM language reference.

I would like a LangRef patch to make the wording more explicit. I assume the semantics here are that it's always legal to replace llvm.annotation return value with its argument, but it's preferred not to do the replacement? Otherwise we could just mark the argument as returned.

[shchenz]

address @nikic comment:

• explicitly doc the behavior for annotation intrinsics
• handle llvm.ptr.annotation too

[Meinersbur]

In D127835#3584810, @nikic wrote:

I would like a LangRef patch to make the wording more explicit. I assume the semantics here are that it's always legal to replace llvm.annotation return value with its argument, but it's preferred not to do the replacement? Otherwise we could just mark the argument as returned.

I guess it's like metadata but for instructions: Not necessary for semantic correctness, but adds additional information that might be useful, even if just a comment. Its design is unfortunate to have an influence on optimization.

Like D102344, I am ok to greenlight this patch if @nikic is.

llvm/docs/LangRef.rst

23616–23622

This sounds like they are removed immediately (even by analyses?), but its just that it is semantically correct to do so while losing some information such as debug info.

Could you use wording such as "transformations preserve annotations on a best-effort basis but are allowed to replace them with their first argument without breaking semantics and are completely dropped during instruction selection"?

[shchenz]

address @Meinersbur comments

llvm/docs/LangRef.rst

23616–23622

Thanks. Updated.

[nikic]

llvm/docs/LangRef.rst

23580

"and they are"?

llvm/lib/Analysis/ScalarEvolution.cpp

7822

Please also add these to getOperandsToCreate() (probably after a rebase).

[shchenz]

address @nikic comments

[nikic]

LGTM

llvm/docs/LangRef.rst

 third is a pointer to a global string which is the source file name, and the
 last argument is the line number. It returns the value of the first argument.
 
 Semantics:
 """"""""""
 
 This intrinsic allows annotation of a pointer to an integer with arbitrary
 strings. This can be useful for special purpose optimizations that want to look
-for these annotations. These have no other defined use; they are ignored by code
-generation and optimization.
+for these annotations. These have no other defined use; transformations preserve
+annotations on a best-effort basis but are allowed to replace the intrinsic with
+its first argument without breaking semantics and the intrinsic is completely
+dropped during instruction selection.
 
 '``llvm.annotation.*``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 This is an overloaded intrinsic. You can use '``llvm.annotation``' on

 The first argument is an integer value (result of some expression), the
 second is a pointer to a global string, the third is a pointer to a
 global string which is the source file name, and the last argument is
 the line number. It returns the value of the first argument.
 
 Semantics:
 """"""""""
 
-This intrinsic allows annotations to be put on arbitrary expressions
-with arbitrary strings. This can be useful for special purpose
-optimizations that want to look for these annotations. These have no
-other defined use; they are ignored by code generation and optimization.
+This intrinsic allows annotations to be put on arbitrary expressions with
+arbitrary strings. This can be useful for special purpose optimizations that
+want to look for these annotations. These have no other defined use;
+transformations preserve annotations on a best-effort basis but are allowed to
+replace the intrinsic with its first argument without breaking semantics and the
+intrinsic is completely dropped during instruction selection.
 
 '``llvm.codeview.annotation``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 This annotation emits a label at its program point and an associated
 ``S_ANNOTATION`` codeview record with some additional string metadata. This is

llvm/lib/Analysis/ScalarEvolution.cpp

if (auto *II = dyn_cast<IntrinsicInst>(U)) {
       case Intrinsic::smax:
       case Intrinsic::smin:
       case Intrinsic::usub_sat:
       case Intrinsic::uadd_sat:
         Ops.push_back(II->getArgOperand(0));
         Ops.push_back(II->getArgOperand(1));
         return nullptr;
       case Intrinsic::start_loop_iterations:
+      case Intrinsic::annotation:
+      case Intrinsic::ptr_annotation:
         Ops.push_back(II->getArgOperand(0));
         return nullptr;
       default:
         break;
       }
     }
     break;
   }
if (auto *II = dyn_cast<IntrinsicInst>(U)) {
       }
       case Intrinsic::uadd_sat: {
         const SCEV *X = getSCEV(II->getArgOperand(0));
         const SCEV *Y = getSCEV(II->getArgOperand(1));
         const SCEV *ClampedX = getUMinExpr(X, getNotSCEV(Y));
         return getAddExpr(ClampedX, Y, SCEV::FlagNUW);
       }
       case Intrinsic::start_loop_iterations:
-        // A start_loop_iterations is just equivalent to the first operand for
-        // SCEV purposes.
+      case Intrinsic::annotation:
+      case Intrinsic::ptr_annotation:
+        // A start_loop_iterations or llvm.annotation or llvm.prt.annotation is
+        // just eqivalent to the first operand for SCEV purposes.
         return getSCEV(II->getArgOperand(0));
       default:
         break;
       }
     }
     break;
   }
 

llvm/test/Analysis/ScalarEvolution/annotation-intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 declare i64 @llvm.annotation.i64(i64, i8*, i8*, i32)
 declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*)
 
 define i64 @annotation(i64 %x) {
 ; CHECK-LABEL: 'annotation'
 ; CHECK-NEXT:  Classifying expressions for: @annotation
 ; CHECK-NEXT:    %1 = tail call i64 @llvm.annotation.i64(i64 %x, i8* null, i8* null, i32 0)
-; CHECK-NEXT:    --> %1 U: full-set S: full-set
+; CHECK-NEXT:    --> %x U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @annotation
 ;
   %1 = tail call i64 @llvm.annotation.i64(i64 %x, i8* null, i8* null, i32 0)
   ret i64 %1
 }
 
 define i8* @ptr_annotation(i8* %x) {
 ; CHECK-LABEL: 'ptr_annotation'
 ; CHECK-NEXT:  Classifying expressions for: @ptr_annotation
 ; CHECK-NEXT:    %1 = call i8* @llvm.ptr.annotation.p0i8(i8* %x, i8* null, i8* null, i32 0, i8* null)
-; CHECK-NEXT:    --> %1 U: full-set S: full-set
+; CHECK-NEXT:    --> %x U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @ptr_annotation
 ;
   %1 = call i8* @llvm.ptr.annotation.p0i8(i8* %x, i8* null, i8* null, i32 0, i8* null)
   ret i8* %1
 }