Lines Matching refs:intrinsic
353 llvm.experimental.patchpoint because only this intrinsic records
1933 handling intrinsic <int_varargs>` functions. '``<returntype>``' is any type
2032 instructions are represented as intrinsic or asm calls with arguments
7222 ``va_arg`` is an LLVM instruction instead of an :ref:`intrinsic
7326 LLVM supports the notion of an "intrinsic function". These functions
7334 prefix is reserved in LLVM for intrinsic names; thus, function names may
7336 functions: you cannot define the body of intrinsic functions. Intrinsic
7338 to take the address of an intrinsic function. Additionally, because
7339 intrinsic functions are part of the LLVM language, it is required if any
7342 Some intrinsic functions can be overloaded, i.e., the intrinsic
7346 intrinsic function to operate on any integer type. One or more of the
7349 previous argument's type or the result type. This allows an intrinsic
7366 To learn how to add an intrinsic function, please see the `Extending
7375 :ref:`va_arg <i_va_arg>` instruction and these three intrinsic
7385 variable argument handling intrinsic functions are used.
7435 The '``llvm.va_start``' intrinsic initializes ``*<arglist>`` for
7446 The '``llvm.va_start``' intrinsic works just like the ``va_start`` macro
7450 function. Unlike the C ``va_start`` macro, this intrinsic does not need
7467 The '``llvm.va_end``' intrinsic destroys ``*<arglist>``, which has been
7478 The '``llvm.va_end``' intrinsic works just like the ``va_end`` macro
7500 The '``llvm.va_copy``' intrinsic copies the current argument position
7512 The '``llvm.va_copy``' intrinsic works just like the ``va_copy`` macro
7515 intrinsic is necessary because the `` llvm.va_start`` intrinsic may be
7522 (GC) requires the frontend to generate code containing appropriate intrinsic
7559 The '``llvm.gcroot``' intrinsic declares the existence of a GC root to
7573 At runtime, a call to this intrinsic stores a null pointer into the
7576 The '``llvm.gcroot``' intrinsic may only be used in a function which
7594 The '``llvm.gcread``' intrinsic identifies reads of references from heap
7609 The '``llvm.gcread``' intrinsic has the same semantics as a load
7612 intrinsic may only be used in a function which :ref:`specifies a GC
7630 The '``llvm.gcwrite``' intrinsic identifies writes of references to heap
7645 The '``llvm.gcwrite``' intrinsic has the same semantics as a store
7648 intrinsic may only be used in a function which :ref:`specifies a GC
7670 The '``llvm.returnaddress``' intrinsic attempts to compute a
7677 The argument to this intrinsic indicates which function to return the
7685 The '``llvm.returnaddress``' intrinsic either returns a pointer
7687 cannot be identified. The value returned by this intrinsic is likely to
7691 Note that calling this intrinsic does not prevent function inlining or
7708 The '``llvm.frameaddress``' intrinsic attempts to return the
7714 The argument to this intrinsic indicates which function to return the
7722 The '``llvm.frameaddress``' intrinsic either returns a pointer
7724 cannot be identified. The value returned by this intrinsic is likely to
7728 Note that calling this intrinsic does not prevent function inlining or
7746 The '``llvm.frameescape``' intrinsic escapes offsets of a collection of static
7747 allocas, and the '``llvm.framerecover``' intrinsic applies those offsets to a
7779 block. The frame allocation intrinsic inhibits inlining, as any frame
7812 The '``llvm.read_register``' intrinsic returns the current value of the
7813 register, where possible. The '``llvm.write_register``' intrinsic sets
7844 The '``llvm.stacksave``' intrinsic is used to remember the current state
7853 This intrinsic returns a opaque pointer value that can be passed to
7855 ``llvm.stackrestore`` intrinsic is executed with a value saved from
7857 the state it was in when the ``llvm.stacksave`` intrinsic executed. In
7876 The '``llvm.stackrestore``' intrinsic is used to restore the state of
7878 :ref:`llvm.stacksave <int_stacksave>` intrinsic executed. This is
7900 The '``llvm.prefetch``' intrinsic is a hint to the code generator to
7919 This intrinsic does not modify the behavior of the program. In
7921 targets that support this intrinsic, the prefetch can provide hints to
7937 The '``llvm.pcmarker``' intrinsic is a method to export a Program
7954 This intrinsic does not modify the behavior of the program. Backends
7955 that do not support this intrinsic may ignore it.
7970 The '``llvm.readcyclecounter``' intrinsic provides access to the cycle
8001 The '``llvm.clear_cache``' intrinsic ensures visibility of modifications
8010 intrinsic is a nop. On platforms with non-coherent instruction and data
8011 cache (e.g. ARM, MIPS), the intrinsic is lowered either to appropriate
8019 of the current function are outside the scope of the intrinsic.
8035 The '``llvm.instrprof_increment``' intrinsic can be emitted by a
8059 This intrinsic represents an increment of a profiling counter. It will
8081 This is an overloaded intrinsic. You can use ``llvm.memcpy`` on any
8111 If the call to this intrinsic has an alignment value that is not 0 or 1,
8134 This is an overloaded intrinsic. You can use llvm.memmove on any integer
8150 '``llvm.memcpy``' intrinsic but allows the two memory locations to
8166 If the call to this intrinsic has an alignment value that is not 0 or 1,
8189 This is an overloaded intrinsic. You can use llvm.memset on any integer
8207 intrinsic does not return a value and takes extra alignment/volatile
8218 If the call to this intrinsic has an alignment value that is not 0 or 1,
8240 This is an overloaded intrinsic. You can use ``llvm.sqrt`` on any
8280 This is an overloaded intrinsic. You can use ``llvm.powi`` on any
8318 This is an overloaded intrinsic. You can use ``llvm.sin`` on any
8354 This is an overloaded intrinsic. You can use ``llvm.cos`` on any
8390 This is an overloaded intrinsic. You can use ``llvm.pow`` on any
8427 This is an overloaded intrinsic. You can use ``llvm.exp`` on any
8462 This is an overloaded intrinsic. You can use ``llvm.exp2`` on any
8497 This is an overloaded intrinsic. You can use ``llvm.log`` on any
8532 This is an overloaded intrinsic. You can use ``llvm.log10`` on any
8567 This is an overloaded intrinsic. You can use ``llvm.log2`` on any
8602 This is an overloaded intrinsic. You can use ``llvm.fma`` on any
8638 This is an overloaded intrinsic. You can use ``llvm.fabs`` on any
8674 This is an overloaded intrinsic. You can use ``llvm.minnum`` on any
8716 This is an overloaded intrinsic. You can use ``llvm.maxnum`` on any
8757 This is an overloaded intrinsic. You can use ``llvm.copysign`` on any
8793 This is an overloaded intrinsic. You can use ``llvm.floor`` on any
8828 This is an overloaded intrinsic. You can use ``llvm.ceil`` on any
8863 This is an overloaded intrinsic. You can use ``llvm.trunc`` on any
8899 This is an overloaded intrinsic. You can use ``llvm.rint`` on any
8936 This is an overloaded intrinsic. You can use ``llvm.nearbyint`` on any
8972 This is an overloaded intrinsic. You can use ``llvm.round`` on any
9014 This is an overloaded intrinsic function. You can use bswap on any
9034 The ``llvm.bswap.i16`` intrinsic returns an i16 value that has the high
9036 intrinsic returns an i32 value that has the four bytes of the input i32
9049 This is an overloaded intrinsic. You can use llvm.ctpop on any integer
9078 The '``llvm.ctpop``' intrinsic counts the 1's in a variable, or within
9087 This is an overloaded intrinsic. You can use ``llvm.ctlz`` on any
9103 The '``llvm.ctlz``' family of intrinsic functions counts the number of
9114 the intrinsic should ensure that a zero as the first argument produces a
9122 The '``llvm.ctlz``' intrinsic counts the leading (most significant)
9134 This is an overloaded intrinsic. You can use ``llvm.cttz`` on any
9150 The '``llvm.cttz``' family of intrinsic functions counts the number of
9161 the intrinsic should ensure that a zero as the first argument produces a
9169 The '``llvm.cttz``' intrinsic counts the trailing (least significant)
9188 This is an overloaded intrinsic. You can use ``llvm.sadd.with.overflow``
9200 The '``llvm.sadd.with.overflow``' family of intrinsic functions perform
9216 The '``llvm.sadd.with.overflow``' family of intrinsic functions perform
9238 This is an overloaded intrinsic. You can use ``llvm.uadd.with.overflow``
9250 The '``llvm.uadd.with.overflow``' family of intrinsic functions perform
9266 The '``llvm.uadd.with.overflow``' family of intrinsic functions perform
9287 This is an overloaded intrinsic. You can use ``llvm.ssub.with.overflow``
9299 The '``llvm.ssub.with.overflow``' family of intrinsic functions perform
9315 The '``llvm.ssub.with.overflow``' family of intrinsic functions perform
9337 This is an overloaded intrinsic. You can use ``llvm.usub.with.overflow``
9349 The '``llvm.usub.with.overflow``' family of intrinsic functions perform
9365 The '``llvm.usub.with.overflow``' family of intrinsic functions perform
9387 This is an overloaded intrinsic. You can use ``llvm.smul.with.overflow``
9399 The '``llvm.smul.with.overflow``' family of intrinsic functions perform
9415 The '``llvm.smul.with.overflow``' family of intrinsic functions perform
9437 This is an overloaded intrinsic. You can use ``llvm.umul.with.overflow``
9449 The '``llvm.umul.with.overflow``' family of intrinsic functions perform
9465 The '``llvm.umul.with.overflow``' family of intrinsic functions perform
9498 The '``llvm.fmuladd.*``' intrinsic functions represent multiply-add
9523 corresponding llvm.fma.\* intrinsic function should be used
9565 The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
9571 The intrinsic function contains single argument - the value to be
9577 The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
9605 The '``llvm.convert.from.fp16``' intrinsic function performs a
9612 The intrinsic function contains single argument - the value to be
9618 The '``llvm.convert.from.fp16``' intrinsic function performs a
9698 The ``llvm.init.trampoline`` intrinsic takes three arguments, all
9701 intrinsic. Note that the size and the alignment are target-specific -
9703 front-end that generates this intrinsic needs to have some
9753 intrinsic returns the executable address corresponding to ``tramp``
9760 …the "off" lanes are not accessed. When all bits of the mask are on, the intrinsic is identical to …
9769 This is an overloaded intrinsic. The loaded data is a vector of any integer or floating point data …
9791 …intrinsic is designed for conditional reading of selected vector elements in a single IR operation…
9792 …d the passthru values, predicated on the same mask. However, using this intrinsic prevents excepti…
9810 This is an overloaded intrinsic. The data stored in memory is a vector of any integer or floating p…
9831 …redicated basic blocks on these targets. Other targets may support this intrinsic differently, for…
9832 …tion is equivalent to a load-modify-store sequence. However, using this intrinsic prevents excepti…
9865 The '``llvm.lifetime.start``' intrinsic specifies the start of a memory
9878 This intrinsic indicates that before this point in the code, the value
9881 that precedes this intrinsic can be replaced with ``'undef'``.
9898 The '``llvm.lifetime.end``' intrinsic specifies the end of a memory
9911 This intrinsic indicates that after this point in the code, the value of
9914 object following this intrinsic may be removed as dead.
9929 The '``llvm.invariant.start``' intrinsic specifies that the contents of
9942 This intrinsic indicates that until an ``llvm.invariant.end`` that uses
9959 The '``llvm.invariant.end``' intrinsic specifies that the contents of a
9965 The first argument is the matching ``llvm.invariant.start`` intrinsic.
9973 This intrinsic indicates that the memory is mutable again.
9994 The '``llvm.var.annotation``' intrinsic.
10006 This intrinsic allows annotation of local variables with arbitrary
10017 This is an overloaded intrinsic. You can use '``llvm.ptr.annotation``' on a
10033 The '``llvm.ptr.annotation``' intrinsic.
10046 This intrinsic allows annotation of a pointer to an integer with arbitrary
10057 This is an overloaded intrinsic. You can use '``llvm.annotation``' on
10071 The '``llvm.annotation``' intrinsic.
10084 This intrinsic allows annotations to be put on arbitrary expressions
10102 The '``llvm.trap``' intrinsic.
10112 This intrinsic is lowered to the target dependent trap instruction. If
10113 the target does not have a trap instruction, this intrinsic will be
10129 The '``llvm.debugtrap``' intrinsic.
10139 This intrinsic is lowered to code which is intended to cause an
10156 The ``llvm.stackprotector`` intrinsic takes the ``guard`` and stores it
10163 The ``llvm.stackprotector`` intrinsic requires two pointer arguments.
10171 This intrinsic causes the prologue/epilogue inserter to force the position of
10192 The ``llvm.stackprotectorcheck`` intrinsic compares ``guard`` against an already
10199 The ``llvm.stackprotectorcheck`` intrinsic requires one pointer argument, the
10205 This intrinsic is provided to perform the stack protector check by comparing
10209 The reason to provide this as an IR level intrinsic instead of implementing it
10211 level without an intrinsic, one would need to create additional basic blocks to
10214 intrinsic, we are able to generate the stack protector basic blocks late in
10231 The ``llvm.objectsize`` intrinsic is designed to provide information to
10241 The ``llvm.objectsize`` intrinsic takes two arguments. The first
10250 The ``llvm.objectsize`` intrinsic is lowered to a constant representing
10261 This is an overloaded intrinsic. You can use ``llvm.expect`` on any
10273 The ``llvm.expect`` intrinsic provides information about expected (the
10279 The ``llvm.expect`` intrinsic takes two arguments. The first argument is
10286 This intrinsic is lowered to the ``val``.
10313 The intrinsic allows the optimizer to assume that the provided condition is
10314 always true whenever the control flow reaches the intrinsic call. No code is
10315 generated for this intrinsic, and instructions that contribute only to the
10320 used by the ``llvm.assume`` intrinsic in order to preserve the instructions
10321 only used to form the intrinsic's input argument. This might prove undesirable
10322 if the extra information provided by the ``llvm.assume`` intrinsic does not cause
10350 The ``llvm.bitset.test`` intrinsic tests whether the given pointer is a
10366 The ``llvm.donothing`` intrinsic doesn't perform any operation. It's one of only
10378 This intrinsic does nothing, and it's removed by optimizers and ignored