Lines Matching +refs:llvm +refs:mode +refs:map
53 .. code-block:: llvm
107 .. code-block:: llvm
113 .. code-block:: llvm
119 .. code-block:: llvm
154 .. code-block:: llvm
255 can only be used for variables like ``llvm.global_ctors`` which llvm
359 llvm.experimental.patchpoint because only this intrinsic records
542 .. code-block:: llvm
611 ``@llvm.used`` or dllexported variables. This assumption may be suppressed
643 .. code-block:: llvm
649 .. code-block:: llvm
656 .. code-block:: llvm
842 .. code-block:: llvm
854 .. code-block:: llvm
878 .. code-block:: llvm
935 .. code-block:: llvm
1003 must be cleared off with :ref:`llvm.stackrestore
1134 .. code-block:: llvm
1163 .. code-block:: llvm
1169 .. code-block:: llvm
1208 .. code-block:: llvm
1216 .. code-block:: llvm
1253 .. code-block:: llvm
1278 .. code-block:: llvm
1322 For example, the intrinsic ``llvm.nvvm.barrier0`` is ``convergent``, so
1500 `SafeStack <http://clang.llvm.org/docs/SafeStack.html>`_
1674 .. code-block:: llvm
1690 .. code-block:: llvm
1750 .. code-block:: llvm
1771 .. code-block:: llvm
1817 If present, specifies that llvm names are mangled in the output. The
1902 .. code-block:: llvm
1975 :ref:`store <i_store>`'s, and :ref:`llvm.memcpy <int_memcpy>`'s may be
1983 llvm.memcpy or llvm.memmove intrinsics even when those intrinsics are
2240 .. code-block:: llvm
2773 .. code-block:: llvm
2794 .. code-block:: llvm
2807 .. code-block:: llvm
2828 .. code-block:: llvm
2850 .. code-block:: llvm
2881 .. code-block:: llvm
2902 .. code-block:: llvm
2945 :ref:`@llvm.memcpy <int_memcpy>`.)
2967 .. code-block:: llvm
3189 .. code-block:: llvm
3197 .. code-block:: llvm
3205 .. code-block:: llvm
3216 .. code-block:: llvm
3225 .. code-block:: llvm
3433 block without telling llvm about the control transfer???)
3475 ARM and ARM's Thumb2 mode:
3490 - ``l``: In Thumb2 mode, low 32-bit GPR registers (``r0-r7``). In ARM mode, same
3492 - ``h``: In Thumb2 mode, a high 32-bit GPR register (``r8-r15``). In ARM mode,
3501 ARM's Thumb1 mode:
3541 - ``m``: A memory address operand. In MIPS-SE mode, allows a base address
3542 register plus 16-bit immediate offset. In MIPS mode, just a base register.
3543 - ``R``: A memory address operand. In MIPS-SE mode, allows a base address
3544 register plus a 9-bit signed offset. In MIPS mode, the same as constraint
3631 - ``L``: An immediate integer, 0xff or 0xffff or (in 64-bit mode only)
3655 32-bit mode, a 64-bit integer operand will get split into two registers). It
3656 is not recommended to use this constraint, as in 64-bit mode, the 64-bit
3840 .. code-block:: llvm
3881 .. code-block:: llvm
3887 .. code-block:: llvm
3899 .. code-block:: llvm
3903 Metadata can be used as function arguments. Here ``llvm.dbg.value``
3906 .. code-block:: llvm
3908 call void @llvm.dbg.value(metadata !24, i64 0, metadata !25)
3913 .. code-block:: llvm
3920 .. code-block:: llvm
3952 .. code-block:: llvm
3962 These descriptors are collected by a named metadata ``!llvm.dbg.cu``. They
3973 .. code-block:: llvm
3988 .. code-block:: llvm
3997 .. code-block:: llvm
4017 .. code-block:: llvm
4031 .. code-block:: llvm
4040 .. code-block:: llvm
4092 .. code-block:: llvm
4103 .. code-block:: llvm
4135 .. code-block:: llvm
4149 .. code-block:: llvm
4162 .. code-block:: llvm
4175 .. code-block:: llvm
4184 .. code-block:: llvm
4193 .. code-block:: llvm
4222 .. code-block:: llvm
4247 .. code-block:: llvm
4264 .. code-block:: llvm
4279 .. code-block:: llvm
4293 .. code-block:: llvm
4305 :ref:`debug intrinsics<dbg_intrinsics>` (such as ``llvm.dbg.declare``) to
4316 .. code-block:: llvm
4328 .. code-block:: llvm
4339 .. code-block:: llvm
4352 .. code-block:: llvm
4365 .. code-block:: llvm
4382 .. code-block:: llvm
4409 The :ref:`llvm.memcpy <int_memcpy>` is often used to implement
4425 .. code-block:: llvm
4475 .. code-block:: llvm
4524 .. code-block:: llvm
4552 .. code-block:: llvm
4570 flow. Similar to the llvm.expect intrinsic, it may be used to alter
4575 '``llvm.loop``'
4582 specified with the name ``llvm.loop``.
4591 .. code-block:: llvm
4598 as user-defined metadata. For example the ``llvm.loop.unroll.count``
4601 .. code-block:: llvm
4603 br i1 %exitcond, label %._crit_edge, label %.lr.ph, !llvm.loop !0
4606 !1 = !{!"llvm.loop.unroll.count", i32 4}
4608 '``llvm.loop.vectorize``' and '``llvm.loop.interleave``'
4611 Metadata prefixed with ``llvm.loop.vectorize`` or ``llvm.loop.interleave`` are
4614 conjunction with ``llvm.loop`` loop identification metadata. The
4615 ``llvm.loop.vectorize`` and ``llvm.loop.interleave`` metadata are only
4617 it believes it is safe to do so. The ``llvm.mem.parallel_loop_access`` metadata
4621 '``llvm.loop.interleave.count``' Metadata
4625 The first operand is the string ``llvm.loop.interleave.count`` and the
4629 .. code-block:: llvm
4631 !0 = !{!"llvm.loop.interleave.count", i32 4}
4633 Note that setting ``llvm.loop.interleave.count`` to 1 disables interleaving
4634 multiple iterations of the loop. If ``llvm.loop.interleave.count`` is set to 0
4637 '``llvm.loop.vectorize.enable``' Metadata
4641 first operand is the string ``llvm.loop.vectorize.enable`` and the second operand
4645 .. code-block:: llvm
4647 !0 = !{!"llvm.loop.vectorize.enable", i1 0}
4648 !1 = !{!"llvm.loop.vectorize.enable", i1 1}
4650 '``llvm.loop.vectorize.width``' Metadata
4654 operand is the string ``llvm.loop.vectorize.width`` and the second
4657 .. code-block:: llvm
4659 !0 = !{!"llvm.loop.vectorize.width", i32 4}
4661 Note that setting ``llvm.loop.vectorize.width`` to 1 disables
4662 vectorization of the loop. If ``llvm.loop.vectorize.width`` is set to
4666 '``llvm.loop.unroll``'
4669 Metadata prefixed with ``llvm.loop.unroll`` are loop unrolling
4670 optimization hints such as the unroll factor. ``llvm.loop.unroll``
4671 metadata should be used in conjunction with ``llvm.loop`` loop
4672 identification metadata. The ``llvm.loop.unroll`` metadata are only
4676 '``llvm.loop.unroll.count``' Metadata
4680 first operand is the string ``llvm.loop.unroll.count`` and the second
4684 .. code-block:: llvm
4686 !0 = !{!"llvm.loop.unroll.count", i32 4}
4691 '``llvm.loop.unroll.disable``' Metadata
4695 which is the string ``llvm.loop.unroll.disable``. For example:
4697 .. code-block:: llvm
4699 !0 = !{!"llvm.loop.unroll.disable"}
4701 '``llvm.loop.unroll.runtime.disable``' Metadata
4705 operand which is the string ``llvm.loop.unroll.runtime.disable``. For example:
4707 .. code-block:: llvm
4709 !0 = !{!"llvm.loop.unroll.runtime.disable"}
4711 '``llvm.loop.unroll.enable``' Metadata
4717 ``llvm.loop.unroll.enable``. For example:
4719 .. code-block:: llvm
4721 !0 = !{!"llvm.loop.unroll.enable"}
4723 '``llvm.loop.unroll.full``' Metadata
4727 metadata has a single operand which is the string ``llvm.loop.unroll.full``.
4730 .. code-block:: llvm
4732 !0 = !{!"llvm.loop.unroll.full"}
4734 '``llvm.loop.licm_versioning.disable``' Metadata
4739 which is the string ``llvm.loop.licm_versioning.disable``. For example:
4741 .. code-block:: llvm
4743 !0 = !{!"llvm.loop.licm_versioning.disable"}
4745 '``llvm.loop.distribute.enable``' Metadata
4754 loop. The first operand is the string ``llvm.loop.distribute.enable`` and the
4758 .. code-block:: llvm
4760 !0 = !{!"llvm.loop.distribute.enable", i1 0}
4761 !1 = !{!"llvm.loop.distribute.enable", i1 1}
4763 This metadata should be used in conjunction with ``llvm.loop`` loop
4766 '``llvm.mem``'
4770 for optimizations are prefixed with ``llvm.mem``.
4772 '``llvm.mem.parallel_loop_access``' Metadata
4775 The ``llvm.mem.parallel_loop_access`` metadata refers to a loop identifier,
4783 ``llvm.mem.parallel_loop_access`` metadata, with ``L1`` and ``L2`` being the
4789 ``llvm.mem.parallel_loop_access`` metadata that refers to that loop, then the
4801 both ``llvm.loop`` and ``llvm.mem.parallel_loop_access``
4804 .. code-block:: llvm
4808 %val0 = load i32, i32* %arrayidx, !llvm.mem.parallel_loop_access !0
4810 store i32 %val0, i32* %arrayidx1, !llvm.mem.parallel_loop_access !0
4812 br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
4822 .. code-block:: llvm
4826 %val1 = load i32, i32* %arrayidx3, !llvm.mem.parallel_loop_access !2
4832 %val0 = load i32, i32* %arrayidx1, !llvm.mem.parallel_loop_access !0
4834 store i32 %val0, i32* %arrayidx2, !llvm.mem.parallel_loop_access !0
4836 br i1 %exitcond, label %inner.for.end, label %inner.for.body, !llvm.loop !1
4840 store i32 %val1, i32* %arrayidx4, !llvm.mem.parallel_loop_access !2
4842 br i1 %exitcond, label %outer.for.end, label %outer.for.body, !llvm.loop !2
4857 value (but see the ``llvm.invariant.group.barrier`` intrinsic which affects
4862 .. code-block:: llvm
4881 %newPtr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
4887 declare i8* @llvm.invariant.group.barrier(i8*)
4899 The ``llvm.module.flags`` named metadata exists in order to facilitate
4904 The ``llvm.module.flags`` metadata contains a list of metadata triplets.
4917 ``llvm.module.flags`` metadata is the union of the modules' flags. That is, for
4919 modules ``llvm.module.flags`` metadata table, and the value for that entry will
4974 .. code-block:: llvm
4984 !llvm.module.flags = !{ !0, !1, !2, !3 }
5004 The behavior is to emit an error if the ``llvm.module.flags`` does not
5082 !llvm.module.flags = !{ !0 }
5126 !llvm.module.flags = !{!0, !1}
5138 "``llvm.metadata``". This section and all globals that start with
5139 "``llvm.``" are reserved for use by LLVM.
5143 The '``llvm.used``' Global Variable
5146 The ``@llvm.used`` global is an array which has
5152 .. code-block:: llvm
5157 @llvm.used = appending global [2 x i8*] [
5160 ], section "llvm.metadata"
5162 If a symbol appears in the ``@llvm.used`` list, then the compiler, assembler,
5166 ``@llvm.used`` list, it cannot be deleted. This is commonly used to represent
5176 The '``llvm.compiler.used``' Global Variable
5179 The ``@llvm.compiler.used`` directive is the same as the ``@llvm.used``
5183 by ``@llvm.used``.
5190 The '``llvm.global_ctors``' Global Variable
5193 .. code-block:: llvm
5196 @llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, void ()* @ctor, i8* @data }]
5198 The ``@llvm.global_ctors`` array contains a list of constructor
5210 The '``llvm.global_dtors``' Global Variable
5213 .. code-block:: llvm
5216 @llvm.global_dtors = appending global [1 x %0] [%0 { i32 65535, void ()* @dtor, i8* @data }]
5218 The ``@llvm.global_dtors`` array contains a list of destructor
5308 .. code-block:: llvm
5353 .. code-block:: llvm
5411 .. code-block:: llvm
5472 .. code-block:: llvm
5568 .. code-block:: llvm
5610 .. code-block:: llvm
5663 .. code-block:: llvm
5714 .. code-block:: llvm
5764 .. code-block:: llvm
5854 .. code-block:: llvm
5893 .. code-block:: llvm
5945 .. code-block:: llvm
5988 .. code-block:: llvm
6042 .. code-block:: llvm
6081 .. code-block:: llvm
6125 .. code-block:: llvm
6171 .. code-block:: llvm
6210 .. code-block:: llvm
6252 .. code-block:: llvm
6307 .. code-block:: llvm
6347 .. code-block:: llvm
6409 .. code-block:: llvm
6458 .. code-block:: llvm
6509 .. code-block:: llvm
6561 .. code-block:: llvm
6660 .. code-block:: llvm
6713 .. code-block:: llvm
6755 .. code-block:: llvm
6803 .. code-block:: llvm
6862 .. code-block:: llvm
6905 .. code-block:: llvm
6972 .. code-block:: llvm
7104 .. code-block:: llvm
7193 .. code-block:: llvm
7250 .. code-block:: llvm
7324 .. code-block:: llvm
7410 .. code-block:: llvm
7482 .. code-block:: llvm
7511 .. code-block:: llvm
7549 .. code-block:: llvm
7568 .. code-block:: llvm
7586 .. code-block:: llvm
7608 .. code-block:: llvm
7613 %A = call <8 x double> @llvm.masked.gather.v8f64(<8 x double*> %ptrs,
7658 .. code-block:: llvm
7699 .. code-block:: llvm
7740 .. code-block:: llvm
7782 .. code-block:: llvm
7822 .. code-block:: llvm
7863 .. code-block:: llvm
7905 .. code-block:: llvm
7947 .. code-block:: llvm
7988 .. code-block:: llvm
8033 .. code-block:: llvm
8077 .. code-block:: llvm
8129 .. code-block:: llvm
8175 .. code-block:: llvm
8268 .. code-block:: llvm
8382 .. code-block:: llvm
8436 .. code-block:: llvm
8486 .. code-block:: llvm
8549 ``llvm::GuaranteedTailCallOpt`` is ``true``.
8602 .. code-block:: llvm
8617 llvm treats calls to some functions with names and arguments that match
8745 .. code-block:: llvm
8818 .. code-block:: llvm
8888 .. code-block:: llvm
8904 Intrinsic function names must all start with an "``llvm.``" prefix. This
8929 ``llvm.ctpop`` function can take an integer of any width and returns an
8931 functions such as ``i8 @llvm.ctpop.i8(i8 %val)`` and
8932 ``i29 @llvm.ctpop.i29(i29 %val)``. Only one type, the return type, is
8958 .. code-block:: llvm
8971 call void @llvm.va_start(i8* %ap2)
8976 ; Demonstrate usage of llvm.va_copy and llvm.va_end
8979 call void @llvm.va_copy(i8* %aq2, i8* %ap2)
8980 call void @llvm.va_end(i8* %aq2)
8983 call void @llvm.va_end(i8* %ap2)
8987 declare void @llvm.va_start(i8*)
8988 declare void @llvm.va_copy(i8*, i8*)
8989 declare void @llvm.va_end(i8*)
8993 '``llvm.va_start``' Intrinsic
9001 declare void @llvm.va_start(i8* <arglist>)
9006 The '``llvm.va_start``' intrinsic initializes ``*<arglist>`` for
9017 The '``llvm.va_start``' intrinsic works just like the ``va_start`` macro
9025 '``llvm.va_end``' Intrinsic
9033 declare void @llvm.va_end(i8* <arglist>)
9038 The '``llvm.va_end``' intrinsic destroys ``*<arglist>``, which has been
9039 initialized previously with ``llvm.va_start`` or ``llvm.va_copy``.
9049 The '``llvm.va_end``' intrinsic works just like the ``va_end`` macro
9052 :ref:`llvm.va_start <int_va_start>` and
9053 :ref:`llvm.va_copy <int_va_copy>` must be matched exactly with calls to
9054 ``llvm.va_end``.
9058 '``llvm.va_copy``' Intrinsic
9066 declare void @llvm.va_copy(i8* <destarglist>, i8* <srcarglist>)
9071 The '``llvm.va_copy``' intrinsic copies the current argument position
9083 The '``llvm.va_copy``' intrinsic works just like the ``va_copy`` macro
9086 intrinsic is necessary because the `` llvm.va_start`` intrinsic may be
9109 to the ``llvm.gcroot`` intrinsics, but are compatible with the ones for
9117 '``llvm.gcroot``' Intrinsic
9125 declare void @llvm.gcroot(i8** %ptrloc, i8* %metadata)
9130 The '``llvm.gcroot``' intrinsic declares the existence of a GC root to
9147 The '``llvm.gcroot``' intrinsic may only be used in a function which
9152 '``llvm.gcread``' Intrinsic
9160 declare i8* @llvm.gcread(i8* %ObjPtr, i8** %Ptr)
9165 The '``llvm.gcread``' intrinsic identifies reads of references from heap
9180 The '``llvm.gcread``' intrinsic has the same semantics as a load
9182 the garbage collector runtime, as needed. The '``llvm.gcread``'
9188 '``llvm.gcwrite``' Intrinsic
9196 declare void @llvm.gcwrite(i8* %P1, i8* %Obj, i8** %P2)
9201 The '``llvm.gcwrite``' intrinsic identifies writes of references to heap
9216 The '``llvm.gcwrite``' intrinsic has the same semantics as a store
9218 the garbage collector runtime, as needed. The '``llvm.gcwrite``'
9228 '``llvm.returnaddress``' Intrinsic
9236 declare i8 *@llvm.returnaddress(i32 <level>)
9241 The '``llvm.returnaddress``' intrinsic attempts to compute a
9256 The '``llvm.returnaddress``' intrinsic either returns a pointer
9266 '``llvm.frameaddress``' Intrinsic
9274 declare i8* @llvm.frameaddress(i32 <level>)
9279 The '``llvm.frameaddress``' intrinsic attempts to return the
9293 The '``llvm.frameaddress``' intrinsic either returns a pointer
9303 '``llvm.localescape``' and '``llvm.localrecover``' Intrinsics
9311 declare void @llvm.localescape(...)
9312 declare i8* @llvm.localrecover(i8* %func, i8* %fp, i32 %idx)
9317 The '``llvm.localescape``' intrinsic escapes offsets of a collection of static
9318 allocas, and the '``llvm.localrecover``' intrinsic applies those offsets to a
9320 computed during frame layout of the caller of ``llvm.localescape``.
9325 All arguments to '``llvm.localescape``' must be pointers to static allocas or
9326 casts of static allocas. Each function can only call '``llvm.localescape``'
9329 The ``func`` argument to '``llvm.localrecover``' must be a constant
9334 The ``fp`` argument to '``llvm.localrecover``' must be a frame pointer of a
9335 call frame that is currently live. The return value of '``llvm.localaddress``'
9339 The ``idx`` argument to '``llvm.localrecover``' indicates which alloca passed to
9340 '``llvm.localescape``' to recover. It is zero-indexed.
9347 '``llvm.localescape``' intrinsic once from the function entry block, and the
9348 child functions can use '``llvm.localrecover``' to access the escaped allocas.
9349 The '``llvm.localescape``' intrinsic blocks inlining, as inlining changes where
9351 '``llvm.localrecover``'.
9356 '``llvm.read_register``' and '``llvm.write_register``' Intrinsics
9364 declare i32 @llvm.read_register.i32(metadata)
9365 declare i64 @llvm.read_register.i64(metadata)
9366 declare void @llvm.write_register.i32(metadata, i32 @value)
9367 declare void @llvm.write_register.i64(metadata, i64 @value)
9373 The '``llvm.read_register``' and '``llvm.write_register``' intrinsics
9381 The '``llvm.read_register``' intrinsic returns the current value of the
9382 register, where possible. The '``llvm.write_register``' intrinsic sets
9400 '``llvm.stacksave``' Intrinsic
9408 declare i8* @llvm.stacksave()
9413 The '``llvm.stacksave``' intrinsic is used to remember the current state
9415 :ref:`llvm.stackrestore <int_stackrestore>`. This is useful for
9423 :ref:`llvm.stackrestore <int_stackrestore>`. When an
9424 ``llvm.stackrestore`` intrinsic is executed with a value saved from
9425 ``llvm.stacksave``, it effectively restores the state of the stack to
9426 the state it was in when the ``llvm.stacksave`` intrinsic executed. In
9428 were allocated after the ``llvm.stacksave`` was executed.
9432 '``llvm.stackrestore``' Intrinsic
9440 declare void @llvm.stackrestore(i8* %ptr)
9445 The '``llvm.stackrestore``' intrinsic is used to restore the state of
9447 :ref:`llvm.stacksave <int_stacksave>` intrinsic executed. This is
9454 See the description for :ref:`llvm.stacksave <int_stacksave>`.
9458 '``llvm.get.dynamic.area.offset``' Intrinsic
9466 declare i32 @llvm.get.dynamic.area.offset.i32()
9467 declare i64 @llvm.get.dynamic.area.offset.i64()
9472 The '``llvm.get.dynamic.area.offset.*``' intrinsic family is used to
9476 :ref:`llvm.stacksave <int_stacksave>` to get a
9491 Although for most targets `llvm.get.dynamic.area.offset <int_get_dynamic_area_offset>`
9495 The return value type of :ref:`llvm.get.dynamic.area.offset <int_get_dynamic_area_offset>`
9498 '``llvm.prefetch``' Intrinsic
9506 declare void @llvm.prefetch(i8* <address>, i32 <rw>, i32 <locality>, i32 <cache type>)
9511 The '``llvm.prefetch``' intrinsic is a hint to the code generator to
9535 '``llvm.pcmarker``' Intrinsic
9543 declare void @llvm.pcmarker(i32 <id>)
9548 The '``llvm.pcmarker``' intrinsic is a method to export a Program
9568 '``llvm.readcyclecounter``' Intrinsic
9576 declare i64 @llvm.readcyclecounter()
9581 The '``llvm.readcyclecounter``' intrinsic provides access to the cycle
9583 targets that support it. On X86, it should map to RDTSC. On Alpha, it
9584 should map to RPCC. As the backing counters overflow quickly (on the
9599 '``llvm.clear_cache``' Intrinsic
9607 declare void @llvm.clear_cache(i8*, i8*)
9612 The '``llvm.clear_cache``' intrinsic ensures visibility of modifications
9632 '``llvm.instrprof_increment``' Intrinsic
9640 declare void @llvm.instrprof_increment(i8* <name>, i64 <hash>,
9646 The '``llvm.instrprof_increment``' intrinsic can be emitted by a
9674 the ``llvm-profdata`` tool.
9676 '``llvm.instrprof_value_profile``' Intrinsic
9684 declare void @llvm.instrprof_value_profile(i8* <name>, i64 <hash>,
9691 The '``llvm.instrprof_value_profile``' intrinsic can be emitted by a
9706 ``llvm.instrprof_*`` that refer to the same name.
9713 ``<include/llvm/ProfileData/InstrProf.h>`` header file. The last argument is the
9722 ``llvm.instrprof_value_profile`` intrinsic with the call to the profile
9725 '``llvm.thread.pointer``' Intrinsic
9733 declare i8* @llvm.thread.pointer()
9738 The '``llvm.thread.pointer``' intrinsic returns the value of the thread
9744 The '``llvm.thread.pointer``' intrinsic returns a pointer to the TLS area
9762 '``llvm.memcpy``' Intrinsic
9768 This is an overloaded intrinsic. You can use ``llvm.memcpy`` on any
9774 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
9776 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
9782 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
9785 Note that, unlike the standard libc function, the ``llvm.memcpy.*``
9802 If the ``isvolatile`` parameter is ``true``, the ``llvm.memcpy`` call is
9809 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
9815 '``llvm.memmove``' Intrinsic
9821 This is an overloaded intrinsic. You can use llvm.memmove on any integer
9827 declare void @llvm.memmove.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
9829 declare void @llvm.memmove.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
9835 The '``llvm.memmove.*``' intrinsics move a block of memory from the
9837 '``llvm.memcpy``' intrinsic but allows the two memory locations to
9840 Note that, unlike the standard libc function, the ``llvm.memmove.*``
9857 If the ``isvolatile`` parameter is ``true``, the ``llvm.memmove`` call
9864 The '``llvm.memmove.*``' intrinsics copy a block of memory from the
9870 '``llvm.memset.*``' Intrinsics
9876 This is an overloaded intrinsic. You can use llvm.memset on any integer
9882 declare void @llvm.memset.p0i8.i32(i8* <dest>, i8 <val>,
9884 declare void @llvm.memset.p0i8.i64(i8* <dest>, i8 <val>,
9890 The '``llvm.memset.*``' intrinsics fill a block of memory with a
9893 Note that, unlike the standard libc function, the ``llvm.memset``
9909 If the ``isvolatile`` parameter is ``true``, the ``llvm.memset`` call is
9916 The '``llvm.memset.*``' intrinsics fill "len" bytes of memory starting
9921 '``llvm.sqrt.*``' Intrinsic
9927 This is an overloaded intrinsic. You can use ``llvm.sqrt`` on any
9933 declare float @llvm.sqrt.f32(float %Val)
9934 declare double @llvm.sqrt.f64(double %Val)
9935 declare x86_fp80 @llvm.sqrt.f80(x86_fp80 %Val)
9936 declare fp128 @llvm.sqrt.f128(fp128 %Val)
9937 declare ppc_fp128 @llvm.sqrt.ppcf128(ppc_fp128 %Val)
9942 The '``llvm.sqrt``' intrinsics return the sqrt of the specified operand,
9944 ``sqrt`` in libm, however, ``llvm.sqrt`` has undefined behavior for
9947 ``llvm.sqrt(-0.0)`` is defined to return -0.0 like IEEE sqrt.
9961 '``llvm.powi.*``' Intrinsic
9967 This is an overloaded intrinsic. You can use ``llvm.powi`` on any
9973 declare float @llvm.powi.f32(float %Val, i32 %power)
9974 declare double @llvm.powi.f64(double %Val, i32 %power)
9975 declare x86_fp80 @llvm.powi.f80(x86_fp80 %Val, i32 %power)
9976 declare fp128 @llvm.powi.f128(fp128 %Val, i32 %power)
9977 declare ppc_fp128 @llvm.powi.ppcf128(ppc_fp128 %Val, i32 %power)
9982 The '``llvm.powi.*``' intrinsics return the first operand raised to the
9999 '``llvm.sin.*``' Intrinsic
10005 This is an overloaded intrinsic. You can use ``llvm.sin`` on any
10011 declare float @llvm.sin.f32(float %Val)
10012 declare double @llvm.sin.f64(double %Val)
10013 declare x86_fp80 @llvm.sin.f80(x86_fp80 %Val)
10014 declare fp128 @llvm.sin.f128(fp128 %Val)
10015 declare ppc_fp128 @llvm.sin.ppcf128(ppc_fp128 %Val)
10020 The '``llvm.sin.*``' intrinsics return the sine of the operand.
10035 '``llvm.cos.*``' Intrinsic
10041 This is an overloaded intrinsic. You can use ``llvm.cos`` on any
10047 declare float @llvm.cos.f32(float %Val)
10048 declare double @llvm.cos.f64(double %Val)
10049 declare x86_fp80 @llvm.cos.f80(x86_fp80 %Val)
10050 declare fp128 @llvm.cos.f128(fp128 %Val)
10051 declare ppc_fp128 @llvm.cos.ppcf128(ppc_fp128 %Val)
10056 The '``llvm.cos.*``' intrinsics return the cosine of the operand.
10071 '``llvm.pow.*``' Intrinsic
10077 This is an overloaded intrinsic. You can use ``llvm.pow`` on any
10083 declare float @llvm.pow.f32(float %Val, float %Power)
10084 declare double @llvm.pow.f64(double %Val, double %Power)
10085 declare x86_fp80 @llvm.pow.f80(x86_fp80 %Val, x86_fp80 %Power)
10086 declare fp128 @llvm.pow.f128(fp128 %Val, fp128 %Power)
10087 declare ppc_fp128 @llvm.pow.ppcf128(ppc_fp128 %Val, ppc_fp128 Power)
10092 The '``llvm.pow.*``' intrinsics return the first operand raised to the
10108 '``llvm.exp.*``' Intrinsic
10114 This is an overloaded intrinsic. You can use ``llvm.exp`` on any
10120 declare float @llvm.exp.f32(float %Val)
10121 declare double @llvm.exp.f64(double %Val)
10122 declare x86_fp80 @llvm.exp.f80(x86_fp80 %Val)
10123 declare fp128 @llvm.exp.f128(fp128 %Val)
10124 declare ppc_fp128 @llvm.exp.ppcf128(ppc_fp128 %Val)
10129 The '``llvm.exp.*``' intrinsics perform the exp function.
10143 '``llvm.exp2.*``' Intrinsic
10149 This is an overloaded intrinsic. You can use ``llvm.exp2`` on any
10155 declare float @llvm.exp2.f32(float %Val)
10156 declare double @llvm.exp2.f64(double %Val)
10157 declare x86_fp80 @llvm.exp2.f80(x86_fp80 %Val)
10158 declare fp128 @llvm.exp2.f128(fp128 %Val)
10159 declare ppc_fp128 @llvm.exp2.ppcf128(ppc_fp128 %Val)
10164 The '``llvm.exp2.*``' intrinsics perform the exp2 function.
10178 '``llvm.log.*``' Intrinsic
10184 This is an overloaded intrinsic. You can use ``llvm.log`` on any
10190 declare float @llvm.log.f32(float %Val)
10191 declare double @llvm.log.f64(double %Val)
10192 declare x86_fp80 @llvm.log.f80(x86_fp80 %Val)
10193 declare fp128 @llvm.log.f128(fp128 %Val)
10194 declare ppc_fp128 @llvm.log.ppcf128(ppc_fp128 %Val)
10199 The '``llvm.log.*``' intrinsics perform the log function.
10213 '``llvm.log10.*``' Intrinsic
10219 This is an overloaded intrinsic. You can use ``llvm.log10`` on any
10225 declare float @llvm.log10.f32(float %Val)
10226 declare double @llvm.log10.f64(double %Val)
10227 declare x86_fp80 @llvm.log10.f80(x86_fp80 %Val)
10228 declare fp128 @llvm.log10.f128(fp128 %Val)
10229 declare ppc_fp128 @llvm.log10.ppcf128(ppc_fp128 %Val)
10234 The '``llvm.log10.*``' intrinsics perform the log10 function.
10248 '``llvm.log2.*``' Intrinsic
10254 This is an overloaded intrinsic. You can use ``llvm.log2`` on any
10260 declare float @llvm.log2.f32(float %Val)
10261 declare double @llvm.log2.f64(double %Val)
10262 declare x86_fp80 @llvm.log2.f80(x86_fp80 %Val)
10263 declare fp128 @llvm.log2.f128(fp128 %Val)
10264 declare ppc_fp128 @llvm.log2.ppcf128(ppc_fp128 %Val)
10269 The '``llvm.log2.*``' intrinsics perform the log2 function.
10283 '``llvm.fma.*``' Intrinsic
10289 This is an overloaded intrinsic. You can use ``llvm.fma`` on any
10295 declare float @llvm.fma.f32(float %a, float %b, float %c)
10296 declare double @llvm.fma.f64(double %a, double %b, double %c)
10297 declare x86_fp80 @llvm.fma.f80(x86_fp80 %a, x86_fp80 %b, x86_fp80 %c)
10298 declare fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
10299 declare ppc_fp128 @llvm.fma.ppcf128(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c)
10304 The '``llvm.fma.*``' intrinsics perform the fused multiply-add
10319 '``llvm.fabs.*``' Intrinsic
10325 This is an overloaded intrinsic. You can use ``llvm.fabs`` on any
10331 declare float @llvm.fabs.f32(float %Val)
10332 declare double @llvm.fabs.f64(double %Val)
10333 declare x86_fp80 @llvm.fabs.f80(x86_fp80 %Val)
10334 declare fp128 @llvm.fabs.f128(fp128 %Val)
10335 declare ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128 %Val)
10340 The '``llvm.fabs.*``' intrinsics return the absolute value of the
10355 '``llvm.minnum.*``' Intrinsic
10361 This is an overloaded intrinsic. You can use ``llvm.minnum`` on any
10367 declare float @llvm.minnum.f32(float %Val0, float %Val1)
10368 declare double @llvm.minnum.f64(double %Val0, double %Val1)
10369 declare x86_fp80 @llvm.minnum.f80(x86_fp80 %Val0, x86_fp80 %Val1)
10370 declare fp128 @llvm.minnum.f128(fp128 %Val0, fp128 %Val1)
10371 declare ppc_fp128 @llvm.minnum.ppcf128(ppc_fp128 %Val0, ppc_fp128 %Val1)
10376 The '``llvm.minnum.*``' intrinsics return the minimum of the two
10397 '``llvm.maxnum.*``' Intrinsic
10403 This is an overloaded intrinsic. You can use ``llvm.maxnum`` on any
10409 declare float @llvm.maxnum.f32(float %Val0, float %Val1l)
10410 declare double @llvm.maxnum.f64(double %Val0, double %Val1)
10411 declare x86_fp80 @llvm.maxnum.f80(x86_fp80 %Val0, x86_fp80 %Val1)
10412 declare fp128 @llvm.maxnum.f128(fp128 %Val0, fp128 %Val1)
10413 declare ppc_fp128 @llvm.maxnum.ppcf128(ppc_fp128 %Val0, ppc_fp128 %Val1)
10418 The '``llvm.maxnum.*``' intrinsics return the maximum of the two
10438 '``llvm.copysign.*``' Intrinsic
10444 This is an overloaded intrinsic. You can use ``llvm.copysign`` on any
10450 declare float @llvm.copysign.f32(float %Mag, float %Sgn)
10451 declare double @llvm.copysign.f64(double %Mag, double %Sgn)
10452 declare x86_fp80 @llvm.copysign.f80(x86_fp80 %Mag, x86_fp80 %Sgn)
10453 declare fp128 @llvm.copysign.f128(fp128 %Mag, fp128 %Sgn)
10454 declare ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 %Mag, ppc_fp128 %Sgn)
10459 The '``llvm.copysign.*``' intrinsics return a value with the magnitude of the
10474 '``llvm.floor.*``' Intrinsic
10480 This is an overloaded intrinsic. You can use ``llvm.floor`` on any
10486 declare float @llvm.floor.f32(float %Val)
10487 declare double @llvm.floor.f64(double %Val)
10488 declare x86_fp80 @llvm.floor.f80(x86_fp80 %Val)
10489 declare fp128 @llvm.floor.f128(fp128 %Val)
10490 declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %Val)
10495 The '``llvm.floor.*``' intrinsics return the floor of the operand.
10509 '``llvm.ceil.*``' Intrinsic
10515 This is an overloaded intrinsic. You can use ``llvm.ceil`` on any
10521 declare float @llvm.ceil.f32(float %Val)
10522 declare double @llvm.ceil.f64(double %Val)
10523 declare x86_fp80 @llvm.ceil.f80(x86_fp80 %Val)
10524 declare fp128 @llvm.ceil.f128(fp128 %Val)
10525 declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %Val)
10530 The '``llvm.ceil.*``' intrinsics return the ceiling of the operand.
10544 '``llvm.trunc.*``' Intrinsic
10550 This is an overloaded intrinsic. You can use ``llvm.trunc`` on any
10556 declare float @llvm.trunc.f32(float %Val)
10557 declare double @llvm.trunc.f64(double %Val)
10558 declare x86_fp80 @llvm.trunc.f80(x86_fp80 %Val)
10559 declare fp128 @llvm.trunc.f128(fp128 %Val)
10560 declare ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %Val)
10565 The '``llvm.trunc.*``' intrinsics returns the operand rounded to the
10580 '``llvm.rint.*``' Intrinsic
10586 This is an overloaded intrinsic. You can use ``llvm.rint`` on any
10592 declare float @llvm.rint.f32(float %Val)
10593 declare double @llvm.rint.f64(double %Val)
10594 declare x86_fp80 @llvm.rint.f80(x86_fp80 %Val)
10595 declare fp128 @llvm.rint.f128(fp128 %Val)
10596 declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %Val)
10601 The '``llvm.rint.*``' intrinsics returns the operand rounded to the
10617 '``llvm.nearbyint.*``' Intrinsic
10623 This is an overloaded intrinsic. You can use ``llvm.nearbyint`` on any
10629 declare float @llvm.nearbyint.f32(float %Val)
10630 declare double @llvm.nearbyint.f64(double %Val)
10631 declare x86_fp80 @llvm.nearbyint.f80(x86_fp80 %Val)
10632 declare fp128 @llvm.nearbyint.f128(fp128 %Val)
10633 declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %Val)
10638 The '``llvm.nearbyint.*``' intrinsics returns the operand rounded to the
10653 '``llvm.round.*``' Intrinsic
10659 This is an overloaded intrinsic. You can use ``llvm.round`` on any
10665 declare float @llvm.round.f32(float %Val)
10666 declare double @llvm.round.f64(double %Val)
10667 declare x86_fp80 @llvm.round.f80(x86_fp80 %Val)
10668 declare fp128 @llvm.round.f128(fp128 %Val)
10669 declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %Val)
10674 The '``llvm.round.*``' intrinsics returns the operand rounded to the
10695 '``llvm.bitreverse.*``' Intrinsics
10706 declare i16 @llvm.bitreverse.i16(i16 <id>)
10707 declare i32 @llvm.bitreverse.i32(i32 <id>)
10708 declare i64 @llvm.bitreverse.i64(i64 <id>)
10713 The '``llvm.bitreverse``' family of intrinsics is used to reverse the
10720 The ``llvm.bitreverse.iN`` intrinsic returns an i16 value that has bit
10723 '``llvm.bswap.*``' Intrinsics
10734 declare i16 @llvm.bswap.i16(i16 <id>)
10735 declare i32 @llvm.bswap.i32(i32 <id>)
10736 declare i64 @llvm.bswap.i64(i64 <id>)
10741 The '``llvm.bswap``' family of intrinsics is used to byte swap integer
10749 The ``llvm.bswap.i16`` intrinsic returns an i16 value that has the high
10750 and low byte of the input i16 swapped. Similarly, the ``llvm.bswap.i32``
10754 ``llvm.bswap.i48``, ``llvm.bswap.i64`` and other intrinsics extend this
10758 '``llvm.ctpop.*``' Intrinsic
10764 This is an overloaded intrinsic. You can use llvm.ctpop on any integer
10770 declare i8 @llvm.ctpop.i8(i8 <src>)
10771 declare i16 @llvm.ctpop.i16(i16 <src>)
10772 declare i32 @llvm.ctpop.i32(i32 <src>)
10773 declare i64 @llvm.ctpop.i64(i64 <src>)
10774 declare i256 @llvm.ctpop.i256(i256 <src>)
10775 declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32> <src>)
10780 The '``llvm.ctpop``' family of intrinsics counts the number of bits set
10793 The '``llvm.ctpop``' intrinsic counts the 1's in a variable, or within
10796 '``llvm.ctlz.*``' Intrinsic
10802 This is an overloaded intrinsic. You can use ``llvm.ctlz`` on any
10808 declare i8 @llvm.ctlz.i8 (i8 <src>, i1 <is_zero_undef>)
10809 declare i16 @llvm.ctlz.i16 (i16 <src>, i1 <is_zero_undef>)
10810 declare i32 @llvm.ctlz.i32 (i32 <src>, i1 <is_zero_undef>)
10811 declare i64 @llvm.ctlz.i64 (i64 <src>, i1 <is_zero_undef>)
10812 declare i256 @llvm.ctlz.i256(i256 <src>, i1 <is_zero_undef>)
10813 declare <2 x i32> @llvm.ctlz.v2i32(<2 x i32> <src>, i1 <is_zero_undef>)
10818 The '``llvm.ctlz``' family of intrinsic functions counts the number of
10837 The '``llvm.ctlz``' intrinsic counts the leading (most significant)
10841 ``llvm.ctlz(i32 2) = 30``.
10843 '``llvm.cttz.*``' Intrinsic
10849 This is an overloaded intrinsic. You can use ``llvm.cttz`` on any
10855 declare i8 @llvm.cttz.i8 (i8 <src>, i1 <is_zero_undef>)
10856 declare i16 @llvm.cttz.i16 (i16 <src>, i1 <is_zero_undef>)
10857 declare i32 @llvm.cttz.i32 (i32 <src>, i1 <is_zero_undef>)
10858 declare i64 @llvm.cttz.i64 (i64 <src>, i1 <is_zero_undef>)
10859 declare i256 @llvm.cttz.i256(i256 <src>, i1 <is_zero_undef>)
10860 declare <2 x i32> @llvm.cttz.v2i32(<2 x i32> <src>, i1 <is_zero_undef>)
10865 The '``llvm.cttz``' family of intrinsic functions counts the number of
10884 The '``llvm.cttz``' intrinsic counts the trailing (least significant)
10888 ``llvm.cttz(2) = 1``.
10901 returned by ``llvm.sadd.with.overflow.i32`` is always the same as the
10916 '``llvm.sadd.with.overflow.*``' Intrinsics
10922 This is an overloaded intrinsic. You can use ``llvm.sadd.with.overflow``
10927 declare {i16, i1} @llvm.sadd.with.overflow.i16(i16 %a, i16 %b)
10928 declare {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
10929 declare {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 %b)
10934 The '``llvm.sadd.with.overflow``' family of intrinsic functions perform
10950 The '``llvm.sadd.with.overflow``' family of intrinsic functions perform
10959 .. code-block:: llvm
10961 %res = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
10966 '``llvm.uadd.with.overflow.*``' Intrinsics
10972 This is an overloaded intrinsic. You can use ``llvm.uadd.with.overflow``
10977 declare {i16, i1} @llvm.uadd.with.overflow.i16(i16 %a, i16 %b)
10978 declare {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
10979 declare {i64, i1} @llvm.uadd.with.overflow.i64(i64 %a, i64 %b)
10984 The '``llvm.uadd.with.overflow``' family of intrinsic functions perform
11000 The '``llvm.uadd.with.overflow``' family of intrinsic functions perform
11008 .. code-block:: llvm
11010 %res = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
11015 '``llvm.ssub.with.overflow.*``' Intrinsics
11021 This is an overloaded intrinsic. You can use ``llvm.ssub.with.overflow``
11026 declare {i16, i1} @llvm.ssub.with.overflow.i16(i16 %a, i16 %b)
11027 declare {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
11028 declare {i64, i1} @llvm.ssub.with.overflow.i64(i64 %a, i64 %b)
11033 The '``llvm.ssub.with.overflow``' family of intrinsic functions perform
11049 The '``llvm.ssub.with.overflow``' family of intrinsic functions perform
11058 .. code-block:: llvm
11060 %res = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
11065 '``llvm.usub.with.overflow.*``' Intrinsics
11071 This is an overloaded intrinsic. You can use ``llvm.usub.with.overflow``
11076 declare {i16, i1} @llvm.usub.with.overflow.i16(i16 %a, i16 %b)
11077 declare {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
11078 declare {i64, i1} @llvm.usub.with.overflow.i64(i64 %a, i64 %b)
11083 The '``llvm.usub.with.overflow``' family of intrinsic functions perform
11099 The '``llvm.usub.with.overflow``' family of intrinsic functions perform
11108 .. code-block:: llvm
11110 %res = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
11115 '``llvm.smul.with.overflow.*``' Intrinsics
11121 This is an overloaded intrinsic. You can use ``llvm.smul.with.overflow``
11126 declare {i16, i1} @llvm.smul.with.overflow.i16(i16 %a, i16 %b)
11127 declare {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
11128 declare {i64, i1} @llvm.smul.with.overflow.i64(i64 %a, i64 %b)
11133 The '``llvm.smul.with.overflow``' family of intrinsic functions perform
11149 The '``llvm.smul.with.overflow``' family of intrinsic functions perform
11158 .. code-block:: llvm
11160 %res = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
11165 '``llvm.umul.with.overflow.*``' Intrinsics
11171 This is an overloaded intrinsic. You can use ``llvm.umul.with.overflow``
11176 declare {i16, i1} @llvm.umul.with.overflow.i16(i16 %a, i16 %b)
11177 declare {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
11178 declare {i64, i1} @llvm.umul.with.overflow.i64(i64 %a, i64 %b)
11183 The '``llvm.umul.with.overflow``' family of intrinsic functions perform
11199 The '``llvm.umul.with.overflow``' family of intrinsic functions perform
11208 .. code-block:: llvm
11210 %res = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
11218 '``llvm.canonicalize.*``' Intrinsic
11226 declare float @llvm.canonicalize.f32(float %a)
11227 declare double @llvm.canonicalize.f64(double %b)
11232 The '``llvm.canonicalize.*``' intrinsic returns the platform specific canonical
11263 1.0 and ``llvm.minnum(x, x)`` are possible implementations. Addition with
11264 -0.0 is also sufficient provided that the rounding mode is not -Infinity.
11266 ``@llvm.canonicalize`` must preserve the equality relation. That is:
11268 - ``(@llvm.canonicalize(x) == x)`` is equivalent to ``(x == x)``
11269 - ``(@llvm.canonicalize(x) == @llvm.canonicalize(y))`` is equivalent to
11273 ``@llvm.canonicalize(-0.0) = -0.0`` and ``@llvm.canonicalize(+0.0) = +0.0``
11287 '``llvm.fmuladd.*``' Intrinsic
11295 declare float @llvm.fmuladd.f32(float %a, float %b, float %c)
11296 declare double @llvm.fmuladd.f64(double %a, double %b, double %c)
11301 The '``llvm.fmuladd.*``' intrinsic functions represent multiply-add
11310 The '``llvm.fmuladd.*``' intrinsics each take three arguments: two
11320 %0 = call float @llvm.fmuladd.f32(%a, %b, %c)
11326 corresponding llvm.fma.\* intrinsic function should be used
11327 instead. This never sets errno, just as '``llvm.fma.*``'.
11332 .. code-block:: llvm
11334 … %r2 = call float @llvm.fmuladd.f32(float %a, float %b, float %c) ; yields float:r2 = (a * b) + c
11345 :ref:`llvm.convert.from.fp16 <int_convert_from_fp16>`. Computation can
11349 :ref:`llvm.convert.to.fp16 <int_convert_to_fp16>`, then storing as an
11354 '``llvm.convert.to.fp16``' Intrinsic
11362 declare i16 @llvm.convert.to.fp16.f32(float %a)
11363 declare i16 @llvm.convert.to.fp16.f64(double %a)
11368 The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
11380 The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
11387 .. code-block:: llvm
11389 %res = call i16 @llvm.convert.to.fp16.f32(float %a)
11394 '``llvm.convert.from.fp16``' Intrinsic
11402 declare float @llvm.convert.from.fp16.f32(i16 %a)
11403 declare double @llvm.convert.from.fp16.f64(i16 %a)
11408 The '``llvm.convert.from.fp16``' intrinsic function performs a
11421 The '``llvm.convert.from.fp16``' intrinsic function performs a
11429 .. code-block:: llvm
11432 %res = call float @llvm.convert.from.fp16(i16 %a)
11439 The LLVM debugger intrinsics (which all start with ``llvm.dbg.``
11448 ``llvm.eh.`` prefix), are described in the `LLVM Exception
11469 .. code-block:: llvm
11473 …call i8* @llvm.init.trampoline(i8* %tramp1, i8* bitcast (i32 (i8*, i32, i32)* @f to i8*), i8* %nva…
11474 %p = call i8* @llvm.adjust.trampoline(i8* %tramp1)
11482 '``llvm.init.trampoline``' Intrinsic
11490 declare void @llvm.init.trampoline(i8* <tramp>, i8* <func>, i8* <nval>)
11501 The ``llvm.init.trampoline`` intrinsic takes three arguments, all
11515 passed to :ref:`llvm.adjust.trampoline <int_at>` to get a pointer which can
11522 calling ``llvm.init.trampoline``, the memory pointed to by ``tramp`` is
11528 '``llvm.adjust.trampoline``' Intrinsic
11536 declare i8* @llvm.adjust.trampoline(i8* <tramp>)
11549 :ref:`llvm.init.trampoline <int_it>`.
11569 '``llvm.masked.load.*``' Intrinsics
11578 …declare <16 x float> @llvm.masked.load.v16f32.p0v16f32 (<16 x float>* <ptr>, i32 <alignment>, <16…
11579 …declare <2 x double> @llvm.masked.load.v2f64.p0v2f64 (<2 x double>* <ptr>, i32 <alignment>, <2 x…
11581 …declare <8 x double*> @llvm.masked.load.v8p0f64.p0v8p0f64 (<8 x double*>* <ptr>, i32 <alignment…
11583 …declare <8 x i32 ()*> @llvm.masked.load.v8p0f_i32f.p0v8p0f_i32f (<8 x i32 ()*>* <ptr>, i32 <alignm…
11600 The '``llvm.masked.load``' intrinsic is designed for conditional reading of selected vector element…
11606 …%res = call <16 x float> @llvm.masked.load.v16f32.p0v16f32 (<16 x float>* %ptr, i32 4, <16 x i1>%m…
11614 '``llvm.masked.store.*``' Intrinsics
11623 …declare void @llvm.masked.store.v8i32.p0v8i32 (<8 x i32> <value>, <8 x i32>* <ptr>, i32 <al…
11624 …declare void @llvm.masked.store.v16f32.p0v16f32 (<16 x float> <value>, <16 x float>* <ptr>, i32 <a…
11626 …declare void @llvm.masked.store.v8p0f64.p0v8p0f64 (<8 x double*> <value>, <8 x double*>* <ptr>,…
11628 …declare void @llvm.masked.store.v4p0f_i32f.p0v4p0f_i32f (<4 x i32 ()*> <value>, <4 x i32 ()*>* <pt…
11644 The '``llvm.masked.store``' intrinsics is designed for conditional writing of selected vector eleme…
11649 …call void @llvm.masked.store.v16f32.p0v16f32(<16 x float> %value, <16 x float>* %ptr, i32 4, <16 …
11664 '``llvm.masked.gather.*``' Intrinsics
11673 …declare <16 x float> @llvm.masked.gather.v16f32 (<16 x float*> <ptrs>, i32 <alignment>, <16 x i1…
11674 …declare <2 x double> @llvm.masked.gather.v2f64 (<2 x double*> <ptrs>, i32 <alignment>, <2 x i1>…
11675 …declare <8 x float*> @llvm.masked.gather.v8p0f32 (<8 x float**> <ptrs>, i32 <alignment>, <8 x i1>…
11692 The '``llvm.masked.gather``' intrinsic is designed for conditional reading of multiple scalar value…
11698 …%res = call <4 x double> @llvm.masked.gather.v4f64 (<4 x double*> %ptrs, i32 8, <4 x i1>%mask, <4 …
11718 '``llvm.masked.scatter.*``' Intrinsics
11727 …declare void @llvm.masked.scatter.v8i32 (<8 x i32> <value>, <8 x i32*> <ptrs>, i32 <alig…
11728 …declare void @llvm.masked.scatter.v16f32 (<16 x float> <value>, <16 x float*> <ptrs>, i32 <alig…
11729 …declare void @llvm.masked.scatter.v4p0f64 (<4 x double*> <value>, <4 x double**> <ptrs>, i32 <alig…
11745 The '``llvm.masked.scatter``' intrinsics is designed for writing selected vector elements to arbitr…
11750 …call @llvm.masked.scatter.v8i32 (<8 x i32> %value, <8 x i32*> %ptrs, i32 4, <8 x i1> <true, true…
11776 '``llvm.lifetime.start``' Intrinsic
11784 declare void @llvm.lifetime.start(i64 <size>, i8* nocapture <ptr>)
11789 The '``llvm.lifetime.start``' intrinsic specifies the start of a memory
11809 '``llvm.lifetime.end``' Intrinsic
11817 declare void @llvm.lifetime.end(i64 <size>, i8* nocapture <ptr>)
11822 The '``llvm.lifetime.end``' intrinsic specifies the end of a memory
11840 '``llvm.invariant.start``' Intrinsic
11848 declare {}* @llvm.invariant.start(i64 <size>, i8* nocapture <ptr>)
11853 The '``llvm.invariant.start``' intrinsic specifies that the contents of
11866 This intrinsic indicates that until an ``llvm.invariant.end`` that uses
11870 '``llvm.invariant.end``' Intrinsic
11878 declare void @llvm.invariant.end({}* <start>, i64 <size>, i8* nocapture <ptr>)
11883 The '``llvm.invariant.end``' intrinsic specifies that the contents of a
11889 The first argument is the matching ``llvm.invariant.start`` intrinsic.
11899 '``llvm.invariant.group.barrier``' Intrinsic
11907 declare i8* @llvm.invariant.group.barrier(i8* <ptr>)
11912 The '``llvm.invariant.group.barrier``' intrinsic can be used when an invariant
11920 The ``llvm.invariant.group.barrier`` takes only one argument, which is
11935 '``llvm.var.annotation``' Intrinsic
11943 declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int>)
11948 The '``llvm.var.annotation``' intrinsic.
11965 '``llvm.ptr.annotation.*``' Intrinsic
11971 This is an overloaded intrinsic. You can use '``llvm.ptr.annotation``' on a
11978 … declare i8* @llvm.ptr.annotation.p<address space>i8(i8* <val>, i8* <str>, i8* <str>, i32 <int>)
11979 …declare i16* @llvm.ptr.annotation.p<address space>i16(i16* <val>, i8* <str>, i8* <str>, i32 <int…
11980 …declare i32* @llvm.ptr.annotation.p<address space>i32(i32* <val>, i8* <str>, i8* <str>, i32 <int…
11981 …declare i64* @llvm.ptr.annotation.p<address space>i64(i64* <val>, i8* <str>, i8* <str>, i32 <int…
11982 …declare i256* @llvm.ptr.annotation.p<address space>i256(i256* <val>, i8* <str>, i8* <str>, i32 <i…
11987 The '``llvm.ptr.annotation``' intrinsic.
12005 '``llvm.annotation.*``' Intrinsic
12011 This is an overloaded intrinsic. You can use '``llvm.annotation``' on
12016 declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32 <int>)
12017 declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32 <int>)
12018 declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32 <int>)
12019 declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32 <int>)
12020 declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32 <int>)
12025 The '``llvm.annotation``' intrinsic.
12043 '``llvm.trap``' Intrinsic
12051 declare void @llvm.trap() noreturn nounwind
12056 The '``llvm.trap``' intrinsic.
12070 '``llvm.debugtrap``' Intrinsic
12078 declare void @llvm.debugtrap() nounwind
12083 The '``llvm.debugtrap``' intrinsic.
12097 '``llvm.stackprotector``' Intrinsic
12105 declare void @llvm.stackprotector(i8* <guard>, i8** <slot>)
12110 The ``llvm.stackprotector`` intrinsic takes the ``guard`` and stores it
12117 The ``llvm.stackprotector`` intrinsic requires two pointer arguments.
12129 checked against the original guard by ``llvm.stackprotectorcheck``. If they are
12130 different, then ``llvm.stackprotectorcheck`` causes the program to abort by
12133 '``llvm.stackguard``' Intrinsic
12141 declare i8* @llvm.stackguard()
12146 The ``llvm.stackguard`` intrinsic returns the system stack guard value.
12165 X86 Linux) that is not handled by ``llvm.stackguard()``, while they should be
12168 '``llvm.objectsize``' Intrinsic
12176 declare i32 @llvm.objectsize.i32(i8* <object>, i1 <min>)
12177 declare i64 @llvm.objectsize.i64(i8* <object>, i1 <min>)
12182 The ``llvm.objectsize`` intrinsic is designed to provide information to
12192 The ``llvm.objectsize`` intrinsic takes two arguments. The first
12194 a boolean and determines whether ``llvm.objectsize`` returns 0 (if true)
12201 The ``llvm.objectsize`` intrinsic is lowered to a constant representing
12203 compile time, ``llvm.objectsize`` returns ``i32/i64 -1 or 0`` (depending
12206 '``llvm.expect``' Intrinsic
12212 This is an overloaded intrinsic. You can use ``llvm.expect`` on any
12217 declare i1 @llvm.expect.i1(i1 <val>, i1 <expected_val>)
12218 declare i32 @llvm.expect.i32(i32 <val>, i32 <expected_val>)
12219 declare i64 @llvm.expect.i64(i64 <val>, i64 <expected_val>)
12224 The ``llvm.expect`` intrinsic provides information about expected (the
12230 The ``llvm.expect`` intrinsic takes two arguments. The first argument is
12241 '``llvm.assume``' Intrinsic
12249 declare void @llvm.assume(i1 %cond)
12254 The ``llvm.assume`` allows the optimizer to assume that the provided
12273 used by the ``llvm.assume`` intrinsic in order to preserve the instructions
12275 if the extra information provided by the ``llvm.assume`` intrinsic does not cause
12277 ``llvm.assume`` should not be used to document basic mathematical invariants
12283 '``llvm.type.test``' Intrinsic
12291 declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
12303 The ``llvm.type.test`` intrinsic tests whether the given pointer is associated
12306 '``llvm.type.checked.load``' Intrinsic
12314 …declare {i8*, i1} @llvm.type.checked.load(i8* %ptr, i32 %offset, metadata %type) argmemonly nounwi…
12328 The ``llvm.type.checked.load`` intrinsic safely loads a function pointer from a
12331 virtual call optimization pass will optimize away ``llvm.type.checked.load``
12360 '``llvm.donothing``' Intrinsic
12368 declare void @llvm.donothing() nounwind readnone
12373 The ``llvm.donothing`` intrinsic doesn't perform any operation. It's one of only
12374 three intrinsics (besides ``llvm.experimental.patchpoint`` and
12375 ``llvm.experimental.gc.statepoint``) that can be called with an invoke
12389 '``llvm.experimental.deoptimize``' Intrinsic
12397 declare type @llvm.experimental.deoptimize(...) [ "deopt"(...) ]
12423 The ``@llvm.experimental.deoptimize`` intrinsic executes an attached
12434 calls to ``@llvm.experimental.deoptimize`` must be in "tail position":
12436 - ``@llvm.experimental.deoptimize`` cannot be invoked.
12439 ``@llvm.experimental.deoptimize`` call if there is one, or void.
12442 ``@llvm.experimental.deoptimize`` will match the return type of its immediate
12449 All declarations of ``@llvm.experimental.deoptimize`` must share the
12457 Calls to ``@llvm.experimental.deoptimize`` are lowered to calls to the
12460 ``@llvm.experimental.deoptimize`` are lowered as if they were formal
12464 '``llvm.experimental.guard``' Intrinsic
12472 declare void @llvm.experimental.guard(i1, ...) [ "deopt"(...) ]
12480 ``@llvm.experimental.guard`` is defined in terms of
12481 ``@llvm.experimental.deoptimize`` -- its body is defined to be
12484 .. code-block:: llvm
12486 define void @llvm.experimental.guard(i1 %pred, <args...>) {
12491 call void @llvm.experimental.deoptimize(<args...>) [ "deopt"() ]
12503 In words, ``@llvm.experimental.guard`` executes the attached
12510 ``@llvm.experimental.guard`` cannot be invoked.
12513 '``llvm.load.relative``' Intrinsic
12521 declare i8* @llvm.load.relative.iN(i8* %ptr, iN %offset) argmemonly nounwind readonly