Lines Matching defs:intrinsics

688 Similar restrictions apply to intrinsics that might examine the pointer bits,
807 intrinsics returning multiple values. Generally, structs containing scalable
1349     semantics. However, certain intrinsics may require this attribute to be
1351     individual intrinsics.
1443     :ref:`trampoline intrinsics <int_trampoline>`. This is not a valid
2083       to model control dependencies of intrinsics.
2963 that will have been done by one of the ``@llvm.call.preallocated.*`` intrinsics.
3551 or llvm.memmove intrinsics even when those intrinsics are flagged volatile.
3629 Note that in cases where none of the atomic intrinsics are used, this
3795 In particular, constrained intrinsics rule out the "Unchanged NaN propagation"
4173 machine. The operations allowed on it are quite limited. Only few intrinsics
4239 arise from target-specific intrinsics and functions.
6626 - ``DW_OP_LLVM_arg, N`` is used in debug intrinsics that refer to more than one
8054 records the hottest callees) and calls to memory intrinsics such as memcpy,
10700 sophisticated algorithms will want to use target-specific intrinsics to
11031 lifetime-manipulating intrinsics.
13098 function <intrinsics>` because it takes a type as an argument.
13343 These debug records replace the prior :ref:`debug intrinsics<dbg_intrinsics>`.
13345 passed to LLVM; it is an error for both records and intrinsics to appear in the
13347 Source Level Debugging <SourceLevelDebugging.html#format-common-intrinsics>`_
13357 restrictions. Overall, these intrinsics represent an extension mechanism
13383 Overloaded intrinsics will have the names of its overloaded argument
13395 :ref:`Unnamed types <t_opaque>` are encoded as ``s_s``. Overloaded intrinsics
13397 additional ``.<number>`` suffix. This allows differentiating intrinsics with
13404 For target developers who are defining intrinsics for back-end code
13408 maintainers when defining intrinsics is to create separate integer and
13409 FP intrinsics rather than rely on overloading. For example, if different
13412 different intrinsics.
13430 prepared to handle these functions regardless of the type used. The intrinsics
13575 intrinsics in a manner which is appropriate for the target collector.
13577 These intrinsics allow identification of :ref:`GC roots on the
13581 these intrinsics to make use of the LLVM garbage collectors. For more
13584 LLVM provides an second experimental set of intrinsics for describing garbage
13585 collection safepoints in compiled code. These intrinsics are an alternative
13586 to the ``llvm.gcroot`` intrinsics, but are compatible with the ones for
13589 <GarbageCollection.html>`_ documentation. The intrinsics themselves are
13814 intrinsic is actually a family of three intrinsics due to an
13981 These intrinsics are provided by LLVM to expose special features that
14171 These intrinsics allow a group of functions to share access to a set of local
14193 The '``llvm.seh.try.begin``' and '``llvm.seh.try.end``' intrinsics mark
14200 -feh_asynch (aka MSVC -EHa), these two intrinsics are injected to mark _try
14219 The '``llvm.seh.scope.begin``' and '``llvm.seh.scope.end``' intrinsics mark
14231 large number of intrinsics, impede optimization of those operations, and make
14232 compilation slower by introducing many extra basic blocks.  These intrinsics can
14265 '``llvm.write_register``' intrinsics provide access to the named register.
14272 The '``llvm.read_register``' and '``llvm.read_volatile_register``' intrinsics
14374       recent dynamic alloca on the caller's stack. These intrinsics are
14383       These intrinsics return a non-negative integer value that can be used to
14649 the indexes used by the other intrinsics (such as
15042 LLVM provides intrinsics for a few important standard C/C++ library
15043 functions. These intrinsics allow source-language front-ends to pass
15110 Vector intrinsics operate on a per-element basis. The larger element of ``%a``
15141 Vector intrinsics operate on a per-element basis. The smaller element of ``%a``
15172 integers. Vector intrinsics operate on a per-element basis. The larger element
15203 integers. Vector intrinsics operate on a per-element basis. The smaller element
15233 ``1`` if ``%a`` is signed greater than ``%b``. Vector intrinsics operate on a per-element basis.
15262 ``1`` if ``%a`` is unsigned greater than ``%b``. Vector intrinsics operate on a per-element basis.
15293 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
15297 intrinsics do not return a value, takes extra isvolatile
15318 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the source
15352 The '``llvm.memcpy.inline.*``' intrinsics copy a block of memory from the
15357 intrinsics do not return a value, takes extra isvolatile
15378 The '``llvm.memcpy.inline.*``' intrinsics copy a block of memory from the
15409 The '``llvm.memmove.*``' intrinsics move a block of memory from the
15415 intrinsics do not return a value, takes an extra isvolatile
15436 The '``llvm.memmove.*``' intrinsics copy a block of memory from the
15470 The '``llvm.memset.*``' intrinsics fill a block of memory with a
15495 The '``llvm.memset.*``' intrinsics fill "len" bytes of memory starting
15528 The '``llvm.memset.inline.*``' intrinsics fill a block of memory with a
15532 intrinsics do not return a value, take an extra isvolatile argument and the
15553 The '``llvm.memset.inline.*``' intrinsics fill "len" bytes of memory starting
15588 The '``llvm.experimental.memset.pattern.*``' intrinsics fill a block of memory
15648 The '``llvm.sqrt``' intrinsics return the square root of the specified value.
15689 The '``llvm.powi.*``' intrinsics return the first operand raised to the
15729 The '``llvm.sin.*``' intrinsics return the sine of the operand.
15768 The '``llvm.cos.*``' intrinsics return the cosine of the operand.
15805 The '``llvm.tan.*``' intrinsics return the tangent of the operand.
15842 The '``llvm.asin.*``' intrinsics return the arcsine of the operand.
15879 The '``llvm.acos.*``' intrinsics return the arccosine of the operand.
15916 The '``llvm.atan.*``' intrinsics return the arctangent of the operand.
15953 The '``llvm.atan2.*``' intrinsics return the arctangent of ``Y/X`` accounting
15991 The '``llvm.sinh.*``' intrinsics return the hyperbolic sine of the operand.
16028 The '``llvm.cosh.*``' intrinsics return the hyperbolic cosine of the operand.
16065 The '``llvm.tanh.*``' intrinsics return the hyperbolic tangent of the operand.
16104 The '``llvm.sincos.*``' intrinsics returns the sine and cosine of the operand.
16146 The '``llvm.pow.*``' intrinsics return the first operand raised to the
16186 The '``llvm.exp.*``' intrinsics compute the base-e exponential of the specified
16226 The '``llvm.exp2.*``' intrinsics compute the base-2 exponential of the
16266 The '``llvm.exp10.*``' intrinsics compute the base-10 exponential of the
16306 The '``llvm.ldexp.*``' intrinsics perform the ldexp function.
16349 The '``llvm.frexp.*``' intrinsics perform the frexp function.
16404 The '``llvm.log.*``' intrinsics compute the base-e logarithm of the specified
16444 The '``llvm.log10.*``' intrinsics compute the base-10 logarithm of the
16485 The '``llvm.log2.*``' intrinsics compute the base-2 logarithm of the specified
16525 The '``llvm.fma.*``' intrinsics perform the fused multiply-add operation.
16564 The '``llvm.fabs.*``' intrinsics return the absolute value of the
16631 versions of the intrinsics respect the exception behavior.
16695 The '``llvm.minnum.*``' intrinsics return the minimum of the two
16746 The '``llvm.maxnum.*``' intrinsics return the maximum of the two
16796 The '``llvm.minimum.*``' intrinsics return the minimum of the two
16836 The '``llvm.maximum.*``' intrinsics return the maximum of the two
16876 The '``llvm.minimumnum.*``' intrinsics return the minimum of the two
16922 The '``llvm.maximumnum.*``' intrinsics return the maximum of the two
16968 The '``llvm.copysign.*``' intrinsics return a value with the magnitude of the
17009 The '``llvm.floor.*``' intrinsics return the floor of the operand.
17046 The '``llvm.ceil.*``' intrinsics return the ceiling of the operand.
17084 The '``llvm.trunc.*``' intrinsics returns the operand rounded to the
17122 The '``llvm.rint.*``' intrinsics returns the operand rounded to the
17165 The '``llvm.nearbyint.*``' intrinsics returns the operand rounded to the
17207 The '``llvm.round.*``' intrinsics returns the operand rounded to the
17245 The '``llvm.roundeven.*``' intrinsics returns the operand rounded to the nearest
17289 The '``llvm.lround.*``' intrinsics return the operand rounded to the nearest
17327 The '``llvm.llround.*``' intrinsics return the operand rounded to the nearest
17373 The '``llvm.lrint.*``' intrinsics return the operand rounded to the nearest
17414 The '``llvm.llrint.*``' intrinsics return the operand rounded to the nearest
17434 LLVM provides intrinsics for a few important bit manipulation
17458 The '``llvm.bitreverse``' family of intrinsics is used to reverse the
17467 intrinsics, such as ``llvm.bitreverse.v4i32``, operate on a per-element
17491 The '``llvm.bswap``' family of intrinsics is used to byte swap an integer
17503 ``llvm.bswap.i48``, ``llvm.bswap.i64`` and other intrinsics extend this
17505 respectively). The vector intrinsics, such as ``llvm.bswap.v4i32``,
17532 The '``llvm.ctpop``' family of intrinsics counts the number of bits set
17741 LLVM provides intrinsics for fast arithmetic overflow checking.
17743 Each of these intrinsics returns a two-element struct. The first
17759 The behavior of these intrinsics is well-defined for all argument
18383 following intrinsics perform fixed point arithmetic operations on 2 operands
19035 The '``llvm.fmuladd.*``' intrinsics each take three arguments: two
19065 LLVM support several intrinsics to mark a loop as a hardware-loop. They are
19066 hints to the backend which are required to lower these intrinsics further to target
19070 These intrinsics may be modified in the future and are not intended to be used
19072 generating these intrinsics.
19091 The '``llvm.set.loop.iterations.*``' intrinsics are used to specify the
19105 The '``llvm.set.loop.iterations.*``' intrinsics do not perform any arithmetic
19127 The '``llvm.start.loop.iterations.*``' intrinsics are similar to the
19128 '``llvm.set.loop.iterations.*``' intrinsics, used to specify the
19144 The '``llvm.start.loop.iterations.*``' intrinsics do not perform any arithmetic
19165 The '``llvm.test.set.loop.iterations.*``' intrinsics are used to specify the
19180 The '``llvm.test.set.loop.iterations.*``' intrinsics do not perform any
19203 The '``llvm.test.start.loop.iterations.*``' intrinsics are similar to the
19205 intrinsics, used to specify the hardware-loop trip count, but also produce a
19218 The '``llvm.test.start.loop.iterations.*``' intrinsics do not perform any
19242 The '``llvm.loop.decrement.reg.*``' intrinsics are used to lower the loop
19256 The '``llvm.loop.decrement.reg.*``' intrinsics do an integer ``SUB`` of its
19262 optimized. These intrinsics are marked as ``IntrNoDuplicate`` to avoid
19285 intrinsics decrement the loop iteration counter with this value, and return a
19299 The '``llvm.loop.decrement.*``' intrinsics do a ``SUB`` of the loop iteration
19309 intrinsics. Each one takes a vector operand as an input and applies its
19329 The '``llvm.vector.reduce.add.*``' intrinsics do an integer ``ADD``
19353 The '``llvm.vector.reduce.fadd.*``' intrinsics do a floating-point
19407 The '``llvm.vector.reduce.mul.*``' intrinsics do an integer ``MUL``
19431 The '``llvm.vector.reduce.fmul.*``' intrinsics do a floating-point
19483 The '``llvm.vector.reduce.and.*``' intrinsics do a bitwise ``AND``
19506 The '``llvm.vector.reduce.or.*``' intrinsics do a bitwise ``OR`` reduction
19529 The '``llvm.vector.reduce.xor.*``' intrinsics do a bitwise ``XOR``
19552 The '``llvm.vector.reduce.smax.*``' intrinsics do a signed integer
19575 The '``llvm.vector.reduce.smin.*``' intrinsics do a signed integer
19598 The '``llvm.vector.reduce.umax.*``' intrinsics do an unsigned
19621 The '``llvm.vector.reduce.umin.*``' intrinsics do an unsigned
19645 The '``llvm.vector.reduce.fmax.*``' intrinsics do a floating-point
19678 The '``llvm.vector.reduce.fmin.*``' intrinsics do a floating-point
19711 The '``llvm.vector.reduce.fmaximum.*``' intrinsics do a floating-point
19740 The '``llvm.vector.reduce.fminimum.*``' intrinsics do a floating-point
19774 The '``llvm.vector.insert.*``' intrinsics insert a vector into another vector
19820 The '``llvm.vector.extract.*``' intrinsics extract a vector from within another
19858 The '``llvm.vector.reverse.*``' intrinsics reverse a vector.
19860 with the original lane order reversed. These intrinsics work for both fixed
19994 The '``llvm.vector.splice.*``' intrinsics construct a vector by
20004 These intrinsics work for both fixed and scalable vectors. While this intrinsic
20038 The '``llvm.stepvector``' intrinsics are used to create vectors
20045 These intrinsics work for both fixed and scalable vectors. While this intrinsic
20071 The '``llvm.experimental.get.vector.length.*``' intrinsics take a number of
20091 This intrinsic is intended to be used by loop vectorization with VP intrinsics
20131 The '``llvm.vector.experimental.partial.reduce.add.*``' intrinsics reduce the
20148 These intrinsics are overloaded.
20150 These intrinsics represent histogram-like operations; that is, updating values
20182 The '``llvm.experimental.vector.histogram.*``' intrinsics are used to perform
20183 updates on potentially overlapping values in memory. The intrinsics represent
20355 or the memory layout) can be expressed using the matrix intrinsics. These
20356 intrinsics require matrix dimensions to be passed as immediate arguments, and
20360 is assumed.  The intrinsics support both integer and floating point matrixes.
20377 The '``llvm.matrix.transpose.*``' intrinsics treat ``%In`` as a ``<Rows> x
20403 The '``llvm.matrix.multiply.*``' intrinsics treat ``%A`` as a ``<OuterRows> x
20434 The '``llvm.matrix.column.major.load.*``' intrinsics load a ``<Rows> x <Cols>``
20474 The '``llvm.matrix.column.major.store.*``' intrinsics store the ``<Rows> x
20603 representable by the result type. These intrinsics provide an alternative
20715 The LLVM convergence intrinsics for controlling the semantics of ``convergent``
20724 The LLVM debugger intrinsics (which all start with ``llvm.dbg.``
20726 Debugging <SourceLevelDebugging.html#format-common-intrinsics>`_
20732 The LLVM exception handling intrinsics (which all start with
20734 Handling <ExceptionHandling.html#format-common-intrinsics>`_ document.
20739 The LLVM pointer authentication intrinsics (which all start with
20741 <PointerAuth.html#intrinsics>`_ document.
20748 These intrinsics make it possible to excise one parameter, marked with
20854 VP intrinsics are intended for predicated SIMD/vector code.  A typical VP
23565 The '``llvm.get.active.lane.mask.*``' intrinsics are semantically equivalent
23586 ``%n`` is the loop tripcount. Thus, these intrinsics perform an element-wise
23595 intrinsics provide a hint to the backend. I.e., for a vector loop, the
25863 LLVM provides intrinsics for predicated vector load and store operations. The predicate is specified by a mask argument, which holds one bit per vector element, switching the associated vector lane on or off. The memory addresses corresponding to the "off" lanes are not accessed. When all bits of the mask are on, the intrinsic is identical to a regular vector load or store. When all bits are off, no memory is accessed.
25940 The '``llvm.masked.store``' intrinsics is designed for conditional writing of selected vector elements in a single IR operation. It is useful for targets that support vector masked store and allows vectorizing predicated basic blocks on these targets. Other targets may support this intrinsic differently, for example by lowering it into a sequence of branches that guard scalar store operations.
25959 LLVM provides intrinsics for vector gather and scatter operations. They are similar to :ref:`Masked Vector Load and Store <int_mload_mstore>`, except they are designed for arbitrary memory accesses, rather than sequential memory accesses. Gather and scatter also employ a mask argument, which holds one bit per vector element, switching the associated vector lane on or off. The memory addresses corresponding to the "off" lanes are not accessed. When all bits are off, no memory is accessed.
26042 The '``llvm.masked.scatter``' intrinsics is designed for writing selected vector elements to arbitrary memory addresses in a single IR operation. The operation may be conditional, when not all bits in the mask are switched on. It is useful for targets that support vector masked scatter and allows vectorizing basic blocks with data and control divergence. Other targets may support this intrinsic differently, for example by lowering it into a sequence of branches that guard scalar store operations.
26068 LLVM provides intrinsics for expanding load and compressing store operations. Data selected from a vector according to a mask is stored in consecutive memory addresses (compressed store), and vice-versa (expanding load). These operations effective map to "if (cond.i) a[j++] = v.i" and "if (cond.i) v.i = a[j++]" patterns, respectively. Note that when the mask starts with '1' bits followed by '0' bits, these operations are identical to :ref:`llvm.masked.store <int_mstore>` and :ref:`llvm.masked.load <int_mload>`.
26193 This class of intrinsics provides information about the
26427 These intrinsics are used to provide special handling of floating-point
26431 Constrained FP intrinsics are used to support non-default rounding modes and
26440 mark constrained intrinsics as having LLVM's default behavior.
26442 Each of these intrinsics corresponds to a normal floating-point operation. The
26448 values. Some constrained FP intrinsics omit this argument. If required
26519 constrained intrinsics to function correctly.
26522 point intrinsics must have the ``strictfp`` attribute either on the
26526 All function *definitions* that use constrained floating point intrinsics
26707 consistency with the other constrained floating-point intrinsics.
26982 '``llvm.experimental.constrained.fcmps``' intrinsics return a boolean
27000 and '``llvm.experimental.constrained.fcmps``' intrinsics must be
27143 intrinsics are described above, there are constrained versions of various
27145 These intrinsics allow the precise behavior of these operations with respect to
27148 As with the basic constrained floating-point intrinsics, the rounding mode
28465 Floating Point Environment Manipulation intrinsics
28799 This class of intrinsics is designed to be generic and has no specific
29327 intrinsics associated with devirtualized calls, thereby removing the type
29427 three intrinsics (besides ``llvm.experimental.patchpoint`` and
30063 LLVM provides experimental intrinsics to support runtime patching
30064 mechanisms commonly desired in dynamic language JITs. These intrinsics
30070 These intrinsics are similar to the standard library memory intrinsics except
30303 LLVM provides intrinsics that lower to Objective-C ARC runtime entry points.
30563 These intrinsics are used to carry certain debuginfo together with
30707 intrinsics section.