Lines Matching +refs:llvm +refs:mode +refs:syntax +refs:table
53 .. code-block:: llvm
92 with a temporary variable without having to avoid symbol table
107 .. code-block:: llvm
113 .. code-block:: llvm
119 .. code-block:: llvm
149 functions, global variables, and symbol table entries. Modules may be
152 symbol table entries. Here is an example of the "hello world" module:
154 .. code-block:: llvm
201 doesn't show up in any symbol table in the object file.
255 can only be used for variables like ``llvm.global_ctors`` which llvm
359 llvm.experimental.patchpoint because only this intrinsic records
360 the location of its arguments in a side table. See :doc:`StackMaps`.
467 dynamic symbol table, so no other module (executable or shared
471 placed in the dynamic symbol table, but that references within the
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
693 (giving the basic block a symbol table entry), contains a list of instructions,
842 .. code-block:: llvm
854 .. code-block:: llvm
873 if a collision occurs in the symbol table.
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
1350 jump-instruction table at code-generation time, and that all address-taken
1352 appropriate jump-instruction-table function pointer. Note that this creates
1500 `SafeStack <http://clang.llvm.org/docs/SafeStack.html>`_
1589 an unwind table entry be produced for this function even if we can
1674 .. code-block:: llvm
1690 .. code-block:: llvm
1748 in the ``.ll`` file if desired. The syntax is very simple:
1750 .. code-block:: llvm
1768 how data is to be laid out in memory. The syntax for the data layout is
1771 .. code-block:: llvm
1817 If present, specifies that llvm names are mangled in the output. The
1900 host. The syntax for the target triple is simply:
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
2238 The syntax for the source file name is simply:
2240 .. code-block:: llvm
2365 .. list-table::
2662 describes them all and their syntax.
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
3051 The following is the syntax for constant expressions:
3176 syntax known to LLVM.
3181 support. However, to be clear, the syntax of the template and constraint strings
3182 described here is *not* the same as the syntax accepted by GCC and Clang, and,
3189 .. code-block:: llvm
3197 .. code-block:: llvm
3205 .. code-block:: llvm
3216 .. code-block:: llvm
3225 .. code-block:: llvm
3391 sets. With this syntax, the same alternative in *all* of the items in the
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
3864 All metadata are identified in syntax by a exclamation point ('``!``').
3881 .. code-block:: llvm
3887 .. code-block:: llvm
3896 metadata nodes, which can be looked up in the module symbol table. For
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
4925 .. list-table::
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
5021 .. list-table::
5082 !llvm.module.flags = !{ !0 }
5106 .. list-table::
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
5388 array of pairs of comparison value constants and '``label``'s. The table
5394 The ``switch`` instruction specifies a table of values and destinations.
5395 When the '``switch``' instruction is executed, this table is searched
5406 chained conditional branches or with a lookup table.
5411 .. code-block:: llvm
5420 ; Implement a jump table:
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
6290 table of how this is implemented in various languages, please see
6307 .. code-block:: llvm
6347 .. code-block:: llvm
6409 .. code-block:: llvm
6458 .. code-block:: llvm
6509 .. code-block:: llvm
6544 The truth table used for the '``and``' instruction is:
6561 .. code-block:: llvm
6593 The truth table used for the '``or``' instruction is:
6643 The truth table used for the '``xor``' instruction is:
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
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
12329 virtual table pointer using type metadata. This intrinsic is used to implement
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