[PATCH 02/38] [noalias] D9375: An llvm.noalias intrinsic

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Rebase of D9375

[craig.topper]

llvm/docs/LangRef.rst

17134

Is this intended to be a different LangRef text than the documentation in D68484?

[jeroen.dobbelaere]

llvm/docs/LangRef.rst

17134

No, the 'rebases' are meant to be just a 'rebase' of the original patch from Hal Finkel. The next patch adapts it to the full restrict support. For this part here, the next patch removes this documentation again.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

For review convenience, all changes related to the original local restrict patches have now been incorporated in the full restrict patch series.

llvm/docs/LangRef.rst

 debugger.
 
 '``llvm.stackprotector``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare void @llvm.stackprotector(i8* <guard>, i8** <slot>)
 
 Overview:
 """""""""
 
 The ``llvm.stackprotector`` intrinsic takes the ``guard`` and stores it
 onto the stack at ``slot``. The stack slot is adjusted to ensure that it

 
 The ``llvm.ssa_copy`` intrinsic can be used to attach information to
 operations by copying them and giving them new names.  For example,
 the PredicateInfo utility uses it to build Extended SSA form, and
 attach various forms of information to operands that dominate specific
 uses.  It is not meant for general use, only for building temporary
 renaming forms that require value splits at certain points.
 
+.. _int_noalias:
+
+'``llvm.noalias``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+::
+
+      declare <type>* @llvm.noalias.p<address space><type>(<type>* %ptr, metadata %scopes)
+
+Overview:
+"""""""""
+
+``llvm.noalias`` allows the optimizer to assume that memory accesses using
+pointers :ref:`based <pointeraliasing>` on the return value don't alias with
+memory accesses, tagged with the provided ``noalias`` scope, using pointers not
+derived from the return value.
+
+Arguments:
+""""""""""
+
+The first argument is the pointer on which the aliasing assumption is being
+placed. This pointer value is returned, but parts of the optimizer ignore this
+fact so that data dependencies on the return value will be maintained. The
+aliasing assumptions apply only to uses of pointers
+:ref:`based <pointeraliasing>` on the return value.
+
+The second argument is metadata that is a list of ``noalias`` metadata
+references. The format is identical to that required for ``noalias`` metadata.
+This list should have only one element.
+
+Semantics:
+""""""""""
+
+``llvm.noalias`` allows the optimizer to assume that memory accesses using
+pointers :ref:`based <pointeraliasing>` on from the return value don't alias
+with memory accesses, tagged with compatible ``noalias`` scopes (i.e. the scope
+provided to the intrinsic must be one of the scopes with which the access is
+tagged), using pointers not based on the return value.  See the description of
+``alias.scope`` and ``noalias`` metadata for more information. The aliasing
+assumptions apply only to uses of pointers based on the return value, and
+accesses using those pointers must themselves be tagged with ``noalias``
+metadata with compatible scopes.
+
+Unlike ``alias.scope`` metadata, which applies to only the access to which it
+is attached, the ``llvm.noalias`` intrinsic applies to all pointers based on
+from the return value. Placing an ``llvm.noalias`` intrinsic outside of a loop
+provides a mechanism for communicating that certain memory accesses don't alias
+with uses of a pointer in any loop iteration. This works only if the
+``llvm.noalias`` intrinsic itself dominates the loop body.
+
+Note that the use of ``alias.scope`` metadata does not block potential
+optimizations, as ``llvm.noalias`` might, and so use of  ``alias.scope``
+metadata when possible is recommended. Nevertheless, no code is generated for
+this intrinsic.
+
 .. _type.test:
 
 '``llvm.type.test``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 

llvm/include/llvm/IR/Intrinsics.td

 def int_pcmarker      : Intrinsic<[], [llvm_i32_ty]>;
 
 def int_readcyclecounter : Intrinsic<[llvm_i64_ty]>;
 
 // The assume intrinsic is marked as arbitrarily writing so that proper
 // control dependencies will be maintained.
 def int_assume        : Intrinsic<[], [llvm_i1_ty], [IntrWillReturn]>;
 
+// This intrinsic does not actually write to memory, but it is marked that way
+// to maintain proper control dependencies. The metadata argument refers to a
+// list of alias.scope metadata entries.
+def int_noalias       : Intrinsic<[llvm_anyptr_ty],
+                                  [LLVMMatchType<0>, llvm_metadata_ty],
+                                  [IntrArgMemOnly, Returned<0>]>;
+
 // Stack Protector Intrinsic - The stackprotector intrinsic writes the stack
 // guard to the correct place on the stack frame.
 def int_stackprotector : Intrinsic<[], [llvm_ptr_ty, llvm_ptrptr_ty], []>;
 def int_stackguard : Intrinsic<[llvm_ptr_ty], [], []>;
 
 // A counter increment for instrumentation based profiling.
 def int_instrprof_increment : Intrinsic<[],
                                         [llvm_ptr_ty, llvm_i64_ty,