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.
354 llvm.experimental.patchpoint because only this intrinsic records
355 the location of its arguments in a side table. See :doc:`StackMaps`.
458 dynamic symbol table, so no other module (executable or shared
462 placed in the dynamic symbol table, but that references within the
533 .. code-block:: llvm
599 ``@llvm.used`` or dllexported variables. This assumption may be suppressed
629 .. code-block:: llvm
635 .. code-block:: llvm
642 .. code-block:: llvm
679 (giving the basic block a symbol table entry), contains a list of instructions,
803 .. code-block:: llvm
815 .. code-block:: llvm
834 if a collision occurs in the symbol table.
839 .. code-block:: llvm
896 .. code-block:: llvm
965 must be cleared off with :ref:`llvm.stackrestore
1070 .. code-block:: llvm
1099 .. code-block:: llvm
1105 .. code-block:: llvm
1144 .. code-block:: llvm
1152 .. code-block:: llvm
1189 .. code-block:: llvm
1214 .. code-block:: llvm
1261 jump-instruction table at code-generation time, and that all address-taken
1263 appropriate jump-instruction-table function pointer. Note that this creates
1379 `SafeStack <http://clang.llvm.org/docs/SafeStack.html>`_
1468 an unwind table entry be produced for this function even if we can
1551 .. code-block:: llvm
1567 .. code-block:: llvm
1599 in the ``.ll`` file if desired. The syntax is very simple:
1601 .. code-block:: llvm
1619 how data is to be laid out in memory. The syntax for the data layout is
1622 .. code-block:: llvm
1668 If present, specifies that llvm names are mangled in the output. The
1751 host. The syntax for the target triple is simply:
1753 .. code-block:: llvm
1826 :ref:`store <i_store>`'s, and :ref:`llvm.memcpy <int_memcpy>`'s may be
1834 llvm.memcpy or llvm.memmove intrinsics even when those intrinsics are
2196 .. list-table::
2493 describes them all and their syntax.
2604 .. code-block:: llvm
2625 .. code-block:: llvm
2638 .. code-block:: llvm
2659 .. code-block:: llvm
2681 .. code-block:: llvm
2712 .. code-block:: llvm
2733 .. code-block:: llvm
2776 :ref:`@llvm.memcpy <int_memcpy>`.)
2798 .. code-block:: llvm
2882 The following is the syntax for constant expressions:
3007 syntax known to LLVM.
3012 support. However, to be clear, the syntax of the template and constraint strings
3013 described here is *not* the same as the syntax accepted by GCC and Clang, and,
3020 .. code-block:: llvm
3028 .. code-block:: llvm
3036 .. code-block:: llvm
3047 .. code-block:: llvm
3056 .. code-block:: llvm
3222 sets. With this syntax, the same alternative in *all* of the items in the
3264 block without telling llvm about the control transfer???)
3306 ARM and ARM's Thumb2 mode:
3321 - ``l``: In Thumb2 mode, low 32-bit GPR registers (``r0-r7``). In ARM mode, same
3323 - ``h``: In Thumb2 mode, a high 32-bit GPR register (``r8-r15``). In ARM mode,
3332 ARM's Thumb1 mode:
3372 - ``m``: A memory address operand. In MIPS-SE mode, allows a base address
3373 register plus 16-bit immediate offset. In MIPS mode, just a base register.
3374 - ``R``: A memory address operand. In MIPS-SE mode, allows a base address
3375 register plus a 9-bit signed offset. In MIPS mode, the same as constraint
3456 - ``L``: An immediate integer, 0xff or 0xffff or (in 64-bit mode only)
3480 32-bit mode, a 64-bit integer operand will get split into two registers). It
3481 is not recommended to use this constraint, as in 64-bit mode, the 64-bit
3665 .. code-block:: llvm
3689 All metadata are identified in syntax by a exclamation point ('``!``').
3706 .. code-block:: llvm
3712 .. code-block:: llvm
3721 metadata nodes, which can be looked up in the module symbol table. For
3724 .. code-block:: llvm
3728 Metadata can be used as function arguments. Here ``llvm.dbg.value``
3731 .. code-block:: llvm
3733 call void @llvm.dbg.value(metadata !24, i64 0, metadata !25)
3738 .. code-block:: llvm
3745 .. code-block:: llvm
3777 .. code-block:: llvm
3787 These descriptors are collected by a named metadata ``!llvm.dbg.cu``. They
3798 .. code-block:: llvm
3813 .. code-block:: llvm
3822 .. code-block:: llvm
3842 .. code-block:: llvm
3856 .. code-block:: llvm
3865 .. code-block:: llvm
3904 .. code-block:: llvm
3915 .. code-block:: llvm
3948 .. code-block:: llvm
3962 .. code-block:: llvm
3975 .. code-block:: llvm
3988 .. code-block:: llvm
3997 .. code-block:: llvm
4006 .. code-block:: llvm
4027 .. code-block:: llvm
4052 .. code-block:: llvm
4069 .. code-block:: llvm
4084 .. code-block:: llvm
4098 .. code-block:: llvm
4110 :ref:`debug intrinsics<dbg_intrinsics>` (such as ``llvm.dbg.declare``) to
4121 .. code-block:: llvm
4133 .. code-block:: llvm
4144 .. code-block:: llvm
4157 .. code-block:: llvm
4170 .. code-block:: llvm
4187 .. code-block:: llvm
4214 The :ref:`llvm.memcpy <int_memcpy>` is often used to implement
4230 .. code-block:: llvm
4272 .. code-block:: llvm
4321 .. code-block:: llvm
4349 .. code-block:: llvm
4367 flow. Similar to the llvm.expect intrinsic, it may be used to alter
4372 '``llvm.loop``'
4379 specified with the name ``llvm.loop``.
4388 .. code-block:: llvm
4395 as user-defined metadata. For example the ``llvm.loop.unroll.count``
4398 .. code-block:: llvm
4400 br i1 %exitcond, label %._crit_edge, label %.lr.ph, !llvm.loop !0
4403 !1 = !{!"llvm.loop.unroll.count", i32 4}
4405 '``llvm.loop.vectorize``' and '``llvm.loop.interleave``'
4408 Metadata prefixed with ``llvm.loop.vectorize`` or ``llvm.loop.interleave`` are
4411 conjunction with ``llvm.loop`` loop identification metadata. The
4412 ``llvm.loop.vectorize`` and ``llvm.loop.interleave`` metadata are only
4414 it believes it is safe to do so. The ``llvm.mem.parallel_loop_access`` metadata
4418 '``llvm.loop.interleave.count``' Metadata
4422 The first operand is the string ``llvm.loop.interleave.count`` and the
4426 .. code-block:: llvm
4428 !0 = !{!"llvm.loop.interleave.count", i32 4}
4430 Note that setting ``llvm.loop.interleave.count`` to 1 disables interleaving
4431 multiple iterations of the loop. If ``llvm.loop.interleave.count`` is set to 0
4434 '``llvm.loop.vectorize.enable``' Metadata
4438 first operand is the string ``llvm.loop.vectorize.enable`` and the second operand
4442 .. code-block:: llvm
4444 !0 = !{!"llvm.loop.vectorize.enable", i1 0}
4445 !1 = !{!"llvm.loop.vectorize.enable", i1 1}
4447 '``llvm.loop.vectorize.width``' Metadata
4451 operand is the string ``llvm.loop.vectorize.width`` and the second
4454 .. code-block:: llvm
4456 !0 = !{!"llvm.loop.vectorize.width", i32 4}
4458 Note that setting ``llvm.loop.vectorize.width`` to 1 disables
4459 vectorization of the loop. If ``llvm.loop.vectorize.width`` is set to
4463 '``llvm.loop.unroll``'
4466 Metadata prefixed with ``llvm.loop.unroll`` are loop unrolling
4467 optimization hints such as the unroll factor. ``llvm.loop.unroll``
4468 metadata should be used in conjunction with ``llvm.loop`` loop
4469 identification metadata. The ``llvm.loop.unroll`` metadata are only
4473 '``llvm.loop.unroll.count``' Metadata
4477 first operand is the string ``llvm.loop.unroll.count`` and the second
4481 .. code-block:: llvm
4483 !0 = !{!"llvm.loop.unroll.count", i32 4}
4488 '``llvm.loop.unroll.disable``' Metadata
4492 which is the string ``llvm.loop.unroll.disable``. For example:
4494 .. code-block:: llvm
4496 !0 = !{!"llvm.loop.unroll.disable"}
4498 '``llvm.loop.unroll.runtime.disable``' Metadata
4502 operand which is the string ``llvm.loop.unroll.runtime.disable``. For example:
4504 .. code-block:: llvm
4506 !0 = !{!"llvm.loop.unroll.runtime.disable"}
4508 '``llvm.loop.unroll.enable``' Metadata
4514 ``llvm.loop.unroll.enable``. For example:
4516 .. code-block:: llvm
4518 !0 = !{!"llvm.loop.unroll.enable"}
4520 '``llvm.loop.unroll.full``' Metadata
4524 metadata has a single operand which is the string ``llvm.loop.unroll.full``.
4527 .. code-block:: llvm
4529 !0 = !{!"llvm.loop.unroll.full"}
4531 '``llvm.mem``'
4535 for optimizations are prefixed with ``llvm.mem``.
4537 '``llvm.mem.parallel_loop_access``' Metadata
4540 The ``llvm.mem.parallel_loop_access`` metadata refers to a loop identifier,
4547 ``llvm.mem.parallel_loop_access`` metadata, with ``L1`` and ``L2`` being the
4553 ``llvm.mem.parallel_loop_access`` metadata that refers to that loop, then the
4565 both ``llvm.loop`` and ``llvm.mem.parallel_loop_access``
4568 .. code-block:: llvm
4572 %val0 = load i32, i32* %arrayidx, !llvm.mem.parallel_loop_access !0
4574 store i32 %val0, i32* %arrayidx1, !llvm.mem.parallel_loop_access !0
4576 br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
4586 .. code-block:: llvm
4590 %val1 = load i32, i32* %arrayidx3, !llvm.mem.parallel_loop_access !2
4596 %val0 = load i32, i32* %arrayidx1, !llvm.mem.parallel_loop_access !0
4598 store i32 %val0, i32* %arrayidx2, !llvm.mem.parallel_loop_access !0
4600 br i1 %exitcond, label %inner.for.end, label %inner.for.body, !llvm.loop !1
4604 store i32 %val1, i32* %arrayidx4, !llvm.mem.parallel_loop_access !2
4606 br i1 %exitcond, label %outer.for.end, label %outer.for.body, !llvm.loop !2
4614 '``llvm.bitsets``'
4617 The ``llvm.bitsets`` global metadata is used to implement
4627 value (but see the ``llvm.invariant.group.barrier`` intrinsic which affects
4632 .. code-block:: llvm
4651 %newPtr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
4657 declare i8* @llvm.invariant.group.barrier(i8*)
4669 The ``llvm.module.flags`` named metadata exists in order to facilitate
4674 The ``llvm.module.flags`` metadata contains a list of metadata triplets.
4687 ``llvm.module.flags`` metadata is the union of the modules' flags. That is, for
4689 modules ``llvm.module.flags`` metadata table, and the value for that entry will
4695 .. list-table::
4744 .. code-block:: llvm
4754 !llvm.module.flags = !{ !0, !1, !2, !3 }
4774 The behavior is to emit an error if the ``llvm.module.flags`` does not
4791 .. list-table::
4852 !llvm.module.flags = !{ !0 }
4876 .. list-table::
4896 !llvm.module.flags = !{!0, !1}
4908 "``llvm.metadata``". This section and all globals that start with
4909 "``llvm.``" are reserved for use by LLVM.
4913 The '``llvm.used``' Global Variable
4916 The ``@llvm.used`` global is an array which has
4922 .. code-block:: llvm
4927 @llvm.used = appending global [2 x i8*] [
4930 ], section "llvm.metadata"
4932 If a symbol appears in the ``@llvm.used`` list, then the compiler, assembler,
4936 ``@llvm.used`` list, it cannot be deleted. This is commonly used to represent
4946 The '``llvm.compiler.used``' Global Variable
4949 The ``@llvm.compiler.used`` directive is the same as the ``@llvm.used``
4953 by ``@llvm.used``.
4960 The '``llvm.global_ctors``' Global Variable
4963 .. code-block:: llvm
4966 @llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, void ()* @ctor, i8* @data }]
4968 The ``@llvm.global_ctors`` array contains a list of constructor
4980 The '``llvm.global_dtors``' Global Variable
4983 .. code-block:: llvm
4986 @llvm.global_dtors = appending global [1 x %0] [%0 { i32 65535, void ()* @dtor, i8* @data }]
4988 The ``@llvm.global_dtors`` array contains a list of destructor
5078 .. code-block:: llvm
5123 .. code-block:: llvm
5158 array of pairs of comparison value constants and '``label``'s. The table
5164 The ``switch`` instruction specifies a table of values and destinations.
5165 When the '``switch``' instruction is executed, this table is searched
5176 chained conditional branches or with a lookup table.
5181 .. code-block:: llvm
5190 ; Implement a jump table:
5242 .. code-block:: llvm
5334 .. code-block:: llvm
5376 .. code-block:: llvm
5427 .. code-block:: llvm
5502 .. code-block:: llvm
5555 .. code-block:: llvm
5604 .. code-block:: llvm
5694 .. code-block:: llvm
5733 .. code-block:: llvm
5785 .. code-block:: llvm
5828 .. code-block:: llvm
5882 .. code-block:: llvm
5921 .. code-block:: llvm
5965 .. code-block:: llvm
6011 .. code-block:: llvm
6050 .. code-block:: llvm
6092 .. code-block:: llvm
6130 table of how this is implemented in various languages, please see
6147 .. code-block:: llvm
6187 .. code-block:: llvm
6249 .. code-block:: llvm
6298 .. code-block:: llvm
6349 .. code-block:: llvm
6384 The truth table used for the '``and``' instruction is:
6401 .. code-block:: llvm
6433 The truth table used for the '``or``' instruction is:
6483 The truth table used for the '``xor``' instruction is:
6500 .. code-block:: llvm
6553 .. code-block:: llvm
6595 .. code-block:: llvm
6643 .. code-block:: llvm
6702 .. code-block:: llvm
6745 .. code-block:: llvm
6812 .. code-block:: llvm
6939 .. code-block:: llvm
7020 .. code-block:: llvm
7077 .. code-block:: llvm
7151 .. code-block:: llvm
7237 .. code-block:: llvm
7309 .. code-block:: llvm
7338 .. code-block:: llvm
7376 .. code-block:: llvm
7395 .. code-block:: llvm
7413 .. code-block:: llvm
7435 .. code-block:: llvm
7440 %A = call <8 x double> @llvm.masked.gather.v8f64(<8 x double*> %ptrs,
7485 .. code-block:: llvm
7526 .. code-block:: llvm
7567 .. code-block:: llvm
7609 .. code-block:: llvm
7649 .. code-block:: llvm
7690 .. code-block:: llvm
7732 .. code-block:: llvm
7774 .. code-block:: llvm
7815 .. code-block:: llvm
7860 .. code-block:: llvm
7904 .. code-block:: llvm
7956 .. code-block:: llvm
8002 .. code-block:: llvm
8095 .. code-block:: llvm
8212 .. code-block:: llvm
8269 .. code-block:: llvm
8319 .. code-block:: llvm
8382 ``llvm::GuaranteedTailCallOpt`` is ``true``.
8437 .. code-block:: llvm
8452 llvm treats calls to some functions with names and arguments that match
8580 .. code-block:: llvm
8667 .. code-block:: llvm
8683 Intrinsic function names must all start with an "``llvm.``" prefix. This
8708 ``llvm.ctpop`` function can take an integer of any width and returns an
8710 functions such as ``i8 @llvm.ctpop.i8(i8 %val)`` and
8711 ``i29 @llvm.ctpop.i29(i29 %val)``. Only one type, the return type, is
8737 .. code-block:: llvm
8750 call void @llvm.va_start(i8* %ap2)
8755 ; Demonstrate usage of llvm.va_copy and llvm.va_end
8758 call void @llvm.va_copy(i8* %aq2, i8* %ap2)
8759 call void @llvm.va_end(i8* %aq2)
8762 call void @llvm.va_end(i8* %ap2)
8766 declare void @llvm.va_start(i8*)
8767 declare void @llvm.va_copy(i8*, i8*)
8768 declare void @llvm.va_end(i8*)
8772 '``llvm.va_start``' Intrinsic
8780 declare void @llvm.va_start(i8* <arglist>)
8785 The '``llvm.va_start``' intrinsic initializes ``*<arglist>`` for
8796 The '``llvm.va_start``' intrinsic works just like the ``va_start`` macro
8804 '``llvm.va_end``' Intrinsic
8812 declare void @llvm.va_end(i8* <arglist>)
8817 The '``llvm.va_end``' intrinsic destroys ``*<arglist>``, which has been
8818 initialized previously with ``llvm.va_start`` or ``llvm.va_copy``.
8828 The '``llvm.va_end``' intrinsic works just like the ``va_end`` macro
8831 :ref:`llvm.va_start <int_va_start>` and
8832 :ref:`llvm.va_copy <int_va_copy>` must be matched exactly with calls to
8833 ``llvm.va_end``.
8837 '``llvm.va_copy``' Intrinsic
8845 declare void @llvm.va_copy(i8* <destarglist>, i8* <srcarglist>)
8850 The '``llvm.va_copy``' intrinsic copies the current argument position
8862 The '``llvm.va_copy``' intrinsic works just like the ``va_copy`` macro
8865 intrinsic is necessary because the `` llvm.va_start`` intrinsic may be
8888 to the ``llvm.gcroot`` intrinsics, but are compatible with the ones for
8896 '``llvm.gcroot``' Intrinsic
8904 declare void @llvm.gcroot(i8** %ptrloc, i8* %metadata)
8909 The '``llvm.gcroot``' intrinsic declares the existence of a GC root to
8926 The '``llvm.gcroot``' intrinsic may only be used in a function which
8931 '``llvm.gcread``' Intrinsic
8939 declare i8* @llvm.gcread(i8* %ObjPtr, i8** %Ptr)
8944 The '``llvm.gcread``' intrinsic identifies reads of references from heap
8959 The '``llvm.gcread``' intrinsic has the same semantics as a load
8961 the garbage collector runtime, as needed. The '``llvm.gcread``'
8967 '``llvm.gcwrite``' Intrinsic
8975 declare void @llvm.gcwrite(i8* %P1, i8* %Obj, i8** %P2)
8980 The '``llvm.gcwrite``' intrinsic identifies writes of references to heap
8995 The '``llvm.gcwrite``' intrinsic has the same semantics as a store
8997 the garbage collector runtime, as needed. The '``llvm.gcwrite``'
9007 '``llvm.returnaddress``' Intrinsic
9015 declare i8 *@llvm.returnaddress(i32 <level>)
9020 The '``llvm.returnaddress``' intrinsic attempts to compute a
9035 The '``llvm.returnaddress``' intrinsic either returns a pointer
9045 '``llvm.frameaddress``' Intrinsic
9053 declare i8* @llvm.frameaddress(i32 <level>)
9058 The '``llvm.frameaddress``' intrinsic attempts to return the
9072 The '``llvm.frameaddress``' intrinsic either returns a pointer
9082 '``llvm.localescape``' and '``llvm.localrecover``' Intrinsics
9090 declare void @llvm.localescape(...)
9091 declare i8* @llvm.localrecover(i8* %func, i8* %fp, i32 %idx)
9096 The '``llvm.localescape``' intrinsic escapes offsets of a collection of static
9097 allocas, and the '``llvm.localrecover``' intrinsic applies those offsets to a
9099 computed during frame layout of the caller of ``llvm.localescape``.
9104 All arguments to '``llvm.localescape``' must be pointers to static allocas or
9105 casts of static allocas. Each function can only call '``llvm.localescape``'
9108 The ``func`` argument to '``llvm.localrecover``' must be a constant
9113 The ``fp`` argument to '``llvm.localrecover``' must be a frame pointer of a
9114 call frame that is currently live. The return value of '``llvm.localaddress``'
9118 The ``idx`` argument to '``llvm.localrecover``' indicates which alloca passed to
9119 '``llvm.localescape``' to recover. It is zero-indexed.
9126 '``llvm.localescape``' intrinsic once from the function entry block, and the
9127 child functions can use '``llvm.localrecover``' to access the escaped allocas.
9128 The '``llvm.localescape``' intrinsic blocks inlining, as inlining changes where
9130 '``llvm.localrecover``'.
9135 '``llvm.read_register``' and '``llvm.write_register``' Intrinsics
9143 declare i32 @llvm.read_register.i32(metadata)
9144 declare i64 @llvm.read_register.i64(metadata)
9145 declare void @llvm.write_register.i32(metadata, i32 @value)
9146 declare void @llvm.write_register.i64(metadata, i64 @value)
9152 The '``llvm.read_register``' and '``llvm.write_register``' intrinsics
9160 The '``llvm.read_register``' intrinsic returns the current value of the
9161 register, where possible. The '``llvm.write_register``' intrinsic sets
9179 '``llvm.stacksave``' Intrinsic
9187 declare i8* @llvm.stacksave()
9192 The '``llvm.stacksave``' intrinsic is used to remember the current state
9194 :ref:`llvm.stackrestore <int_stackrestore>`. This is useful for
9202 :ref:`llvm.stackrestore <int_stackrestore>`. When an
9203 ``llvm.stackrestore`` intrinsic is executed with a value saved from
9204 ``llvm.stacksave``, it effectively restores the state of the stack to
9205 the state it was in when the ``llvm.stacksave`` intrinsic executed. In
9207 were allocated after the ``llvm.stacksave`` was executed.
9211 '``llvm.stackrestore``' Intrinsic
9219 declare void @llvm.stackrestore(i8* %ptr)
9224 The '``llvm.stackrestore``' intrinsic is used to restore the state of
9226 :ref:`llvm.stacksave <int_stacksave>` intrinsic executed. This is
9233 See the description for :ref:`llvm.stacksave <int_stacksave>`.
9237 '``llvm.get.dynamic.area.offset``' Intrinsic
9245 declare i32 @llvm.get.dynamic.area.offset.i32()
9246 declare i64 @llvm.get.dynamic.area.offset.i64()
9251 The '``llvm.get.dynamic.area.offset.*``' intrinsic family is used to
9255 :ref:`llvm.stacksave <int_stacksave>` to get a
9270 Although for most targets `llvm.get.dynamic.area.offset <int_get_dynamic_area_offset>`
9274 The return value type of :ref:`llvm.get.dynamic.area.offset <int_get_dynamic_area_offset>`
9277 '``llvm.prefetch``' Intrinsic
9285 declare void @llvm.prefetch(i8* <address>, i32 <rw>, i32 <locality>, i32 <cache type>)
9290 The '``llvm.prefetch``' intrinsic is a hint to the code generator to
9314 '``llvm.pcmarker``' Intrinsic
9322 declare void @llvm.pcmarker(i32 <id>)
9327 The '``llvm.pcmarker``' intrinsic is a method to export a Program
9347 '``llvm.readcyclecounter``' Intrinsic
9355 declare i64 @llvm.readcyclecounter()
9360 The '``llvm.readcyclecounter``' intrinsic provides access to the cycle
9378 '``llvm.clear_cache``' Intrinsic
9386 declare void @llvm.clear_cache(i8*, i8*)
9391 The '``llvm.clear_cache``' intrinsic ensures visibility of modifications
9411 '``llvm.instrprof_increment``' Intrinsic
9419 declare void @llvm.instrprof_increment(i8* <name>, i64 <hash>,
9425 The '``llvm.instrprof_increment``' intrinsic can be emitted by a
9453 the ``llvm-profdata`` tool.
9455 '``llvm.instrprof_value_profile``' Intrinsic
9463 declare void @llvm.instrprof_value_profile(i8* <name>, i64 <hash>,
9470 The '``llvm.instrprof_value_profile``' intrinsic can be emitted by a
9485 ``llvm.instrprof_*`` that refer to the same name.
9492 ``<include/llvm/ProfileData/InstrProf.h>`` header file. The last argument is the
9501 ``llvm.instrprof_value_profile`` intrinsic with the call to the profile
9514 '``llvm.memcpy``' Intrinsic
9520 This is an overloaded intrinsic. You can use ``llvm.memcpy`` on any
9526 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
9528 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
9534 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
9537 Note that, unlike the standard libc function, the ``llvm.memcpy.*``
9554 If the ``isvolatile`` parameter is ``true``, the ``llvm.memcpy`` call is
9561 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
9567 '``llvm.memmove``' Intrinsic
9573 This is an overloaded intrinsic. You can use llvm.memmove on any integer
9579 declare void @llvm.memmove.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
9581 declare void @llvm.memmove.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
9587 The '``llvm.memmove.*``' intrinsics move a block of memory from the
9589 '``llvm.memcpy``' intrinsic but allows the two memory locations to
9592 Note that, unlike the standard libc function, the ``llvm.memmove.*``
9609 If the ``isvolatile`` parameter is ``true``, the ``llvm.memmove`` call
9616 The '``llvm.memmove.*``' intrinsics copy a block of memory from the
9622 '``llvm.memset.*``' Intrinsics
9628 This is an overloaded intrinsic. You can use llvm.memset on any integer
9634 declare void @llvm.memset.p0i8.i32(i8* <dest>, i8 <val>,
9636 declare void @llvm.memset.p0i8.i64(i8* <dest>, i8 <val>,
9642 The '``llvm.memset.*``' intrinsics fill a block of memory with a
9645 Note that, unlike the standard libc function, the ``llvm.memset``
9661 If the ``isvolatile`` parameter is ``true``, the ``llvm.memset`` call is
9668 The '``llvm.memset.*``' intrinsics fill "len" bytes of memory starting
9673 '``llvm.sqrt.*``' Intrinsic
9679 This is an overloaded intrinsic. You can use ``llvm.sqrt`` on any
9685 declare float @llvm.sqrt.f32(float %Val)
9686 declare double @llvm.sqrt.f64(double %Val)
9687 declare x86_fp80 @llvm.sqrt.f80(x86_fp80 %Val)
9688 declare fp128 @llvm.sqrt.f128(fp128 %Val)
9689 declare ppc_fp128 @llvm.sqrt.ppcf128(ppc_fp128 %Val)
9694 The '``llvm.sqrt``' intrinsics return the sqrt of the specified operand,
9696 ``sqrt`` in libm, however, ``llvm.sqrt`` has undefined behavior for
9699 ``llvm.sqrt(-0.0)`` is defined to return -0.0 like IEEE sqrt.
9713 '``llvm.powi.*``' Intrinsic
9719 This is an overloaded intrinsic. You can use ``llvm.powi`` on any
9725 declare float @llvm.powi.f32(float %Val, i32 %power)
9726 declare double @llvm.powi.f64(double %Val, i32 %power)
9727 declare x86_fp80 @llvm.powi.f80(x86_fp80 %Val, i32 %power)
9728 declare fp128 @llvm.powi.f128(fp128 %Val, i32 %power)
9729 declare ppc_fp128 @llvm.powi.ppcf128(ppc_fp128 %Val, i32 %power)
9734 The '``llvm.powi.*``' intrinsics return the first operand raised to the
9751 '``llvm.sin.*``' Intrinsic
9757 This is an overloaded intrinsic. You can use ``llvm.sin`` on any
9763 declare float @llvm.sin.f32(float %Val)
9764 declare double @llvm.sin.f64(double %Val)
9765 declare x86_fp80 @llvm.sin.f80(x86_fp80 %Val)
9766 declare fp128 @llvm.sin.f128(fp128 %Val)
9767 declare ppc_fp128 @llvm.sin.ppcf128(ppc_fp128 %Val)
9772 The '``llvm.sin.*``' intrinsics return the sine of the operand.
9787 '``llvm.cos.*``' Intrinsic
9793 This is an overloaded intrinsic. You can use ``llvm.cos`` on any
9799 declare float @llvm.cos.f32(float %Val)
9800 declare double @llvm.cos.f64(double %Val)
9801 declare x86_fp80 @llvm.cos.f80(x86_fp80 %Val)
9802 declare fp128 @llvm.cos.f128(fp128 %Val)
9803 declare ppc_fp128 @llvm.cos.ppcf128(ppc_fp128 %Val)
9808 The '``llvm.cos.*``' intrinsics return the cosine of the operand.
9823 '``llvm.pow.*``' Intrinsic
9829 This is an overloaded intrinsic. You can use ``llvm.pow`` on any
9835 declare float @llvm.pow.f32(float %Val, float %Power)
9836 declare double @llvm.pow.f64(double %Val, double %Power)
9837 declare x86_fp80 @llvm.pow.f80(x86_fp80 %Val, x86_fp80 %Power)
9838 declare fp128 @llvm.pow.f128(fp128 %Val, fp128 %Power)
9839 declare ppc_fp128 @llvm.pow.ppcf128(ppc_fp128 %Val, ppc_fp128 Power)
9844 The '``llvm.pow.*``' intrinsics return the first operand raised to the
9860 '``llvm.exp.*``' Intrinsic
9866 This is an overloaded intrinsic. You can use ``llvm.exp`` on any
9872 declare float @llvm.exp.f32(float %Val)
9873 declare double @llvm.exp.f64(double %Val)
9874 declare x86_fp80 @llvm.exp.f80(x86_fp80 %Val)
9875 declare fp128 @llvm.exp.f128(fp128 %Val)
9876 declare ppc_fp128 @llvm.exp.ppcf128(ppc_fp128 %Val)
9881 The '``llvm.exp.*``' intrinsics perform the exp function.
9895 '``llvm.exp2.*``' Intrinsic
9901 This is an overloaded intrinsic. You can use ``llvm.exp2`` on any
9907 declare float @llvm.exp2.f32(float %Val)
9908 declare double @llvm.exp2.f64(double %Val)
9909 declare x86_fp80 @llvm.exp2.f80(x86_fp80 %Val)
9910 declare fp128 @llvm.exp2.f128(fp128 %Val)
9911 declare ppc_fp128 @llvm.exp2.ppcf128(ppc_fp128 %Val)
9916 The '``llvm.exp2.*``' intrinsics perform the exp2 function.
9930 '``llvm.log.*``' Intrinsic
9936 This is an overloaded intrinsic. You can use ``llvm.log`` on any
9942 declare float @llvm.log.f32(float %Val)
9943 declare double @llvm.log.f64(double %Val)
9944 declare x86_fp80 @llvm.log.f80(x86_fp80 %Val)
9945 declare fp128 @llvm.log.f128(fp128 %Val)
9946 declare ppc_fp128 @llvm.log.ppcf128(ppc_fp128 %Val)
9951 The '``llvm.log.*``' intrinsics perform the log function.
9965 '``llvm.log10.*``' Intrinsic
9971 This is an overloaded intrinsic. You can use ``llvm.log10`` on any
9977 declare float @llvm.log10.f32(float %Val)
9978 declare double @llvm.log10.f64(double %Val)
9979 declare x86_fp80 @llvm.log10.f80(x86_fp80 %Val)
9980 declare fp128 @llvm.log10.f128(fp128 %Val)
9981 declare ppc_fp128 @llvm.log10.ppcf128(ppc_fp128 %Val)
9986 The '``llvm.log10.*``' intrinsics perform the log10 function.
10000 '``llvm.log2.*``' Intrinsic
10006 This is an overloaded intrinsic. You can use ``llvm.log2`` on any
10012 declare float @llvm.log2.f32(float %Val)
10013 declare double @llvm.log2.f64(double %Val)
10014 declare x86_fp80 @llvm.log2.f80(x86_fp80 %Val)
10015 declare fp128 @llvm.log2.f128(fp128 %Val)
10016 declare ppc_fp128 @llvm.log2.ppcf128(ppc_fp128 %Val)
10021 The '``llvm.log2.*``' intrinsics perform the log2 function.
10035 '``llvm.fma.*``' Intrinsic
10041 This is an overloaded intrinsic. You can use ``llvm.fma`` on any
10047 declare float @llvm.fma.f32(float %a, float %b, float %c)
10048 declare double @llvm.fma.f64(double %a, double %b, double %c)
10049 declare x86_fp80 @llvm.fma.f80(x86_fp80 %a, x86_fp80 %b, x86_fp80 %c)
10050 declare fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
10051 declare ppc_fp128 @llvm.fma.ppcf128(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c)
10056 The '``llvm.fma.*``' intrinsics perform the fused multiply-add
10071 '``llvm.fabs.*``' Intrinsic
10077 This is an overloaded intrinsic. You can use ``llvm.fabs`` on any
10083 declare float @llvm.fabs.f32(float %Val)
10084 declare double @llvm.fabs.f64(double %Val)
10085 declare x86_fp80 @llvm.fabs.f80(x86_fp80 %Val)
10086 declare fp128 @llvm.fabs.f128(fp128 %Val)
10087 declare ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128 %Val)
10092 The '``llvm.fabs.*``' intrinsics return the absolute value of the
10107 '``llvm.minnum.*``' Intrinsic
10113 This is an overloaded intrinsic. You can use ``llvm.minnum`` on any
10119 declare float @llvm.minnum.f32(float %Val0, float %Val1)
10120 declare double @llvm.minnum.f64(double %Val0, double %Val1)
10121 declare x86_fp80 @llvm.minnum.f80(x86_fp80 %Val0, x86_fp80 %Val1)
10122 declare fp128 @llvm.minnum.f128(fp128 %Val0, fp128 %Val1)
10123 declare ppc_fp128 @llvm.minnum.ppcf128(ppc_fp128 %Val0, ppc_fp128 %Val1)
10128 The '``llvm.minnum.*``' intrinsics return the minimum of the two
10149 '``llvm.maxnum.*``' Intrinsic
10155 This is an overloaded intrinsic. You can use ``llvm.maxnum`` on any
10161 declare float @llvm.maxnum.f32(float %Val0, float %Val1l)
10162 declare double @llvm.maxnum.f64(double %Val0, double %Val1)
10163 declare x86_fp80 @llvm.maxnum.f80(x86_fp80 %Val0, x86_fp80 %Val1)
10164 declare fp128 @llvm.maxnum.f128(fp128 %Val0, fp128 %Val1)
10165 declare ppc_fp128 @llvm.maxnum.ppcf128(ppc_fp128 %Val0, ppc_fp128 %Val1)
10170 The '``llvm.maxnum.*``' intrinsics return the maximum of the two
10190 '``llvm.copysign.*``' Intrinsic
10196 This is an overloaded intrinsic. You can use ``llvm.copysign`` on any
10202 declare float @llvm.copysign.f32(float %Mag, float %Sgn)
10203 declare double @llvm.copysign.f64(double %Mag, double %Sgn)
10204 declare x86_fp80 @llvm.copysign.f80(x86_fp80 %Mag, x86_fp80 %Sgn)
10205 declare fp128 @llvm.copysign.f128(fp128 %Mag, fp128 %Sgn)
10206 declare ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 %Mag, ppc_fp128 %Sgn)
10211 The '``llvm.copysign.*``' intrinsics return a value with the magnitude of the
10226 '``llvm.floor.*``' Intrinsic
10232 This is an overloaded intrinsic. You can use ``llvm.floor`` on any
10238 declare float @llvm.floor.f32(float %Val)
10239 declare double @llvm.floor.f64(double %Val)
10240 declare x86_fp80 @llvm.floor.f80(x86_fp80 %Val)
10241 declare fp128 @llvm.floor.f128(fp128 %Val)
10242 declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %Val)
10247 The '``llvm.floor.*``' intrinsics return the floor of the operand.
10261 '``llvm.ceil.*``' Intrinsic
10267 This is an overloaded intrinsic. You can use ``llvm.ceil`` on any
10273 declare float @llvm.ceil.f32(float %Val)
10274 declare double @llvm.ceil.f64(double %Val)
10275 declare x86_fp80 @llvm.ceil.f80(x86_fp80 %Val)
10276 declare fp128 @llvm.ceil.f128(fp128 %Val)
10277 declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %Val)
10282 The '``llvm.ceil.*``' intrinsics return the ceiling of the operand.
10296 '``llvm.trunc.*``' Intrinsic
10302 This is an overloaded intrinsic. You can use ``llvm.trunc`` on any
10308 declare float @llvm.trunc.f32(float %Val)
10309 declare double @llvm.trunc.f64(double %Val)
10310 declare x86_fp80 @llvm.trunc.f80(x86_fp80 %Val)
10311 declare fp128 @llvm.trunc.f128(fp128 %Val)
10312 declare ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %Val)
10317 The '``llvm.trunc.*``' intrinsics returns the operand rounded to the
10332 '``llvm.rint.*``' Intrinsic
10338 This is an overloaded intrinsic. You can use ``llvm.rint`` on any
10344 declare float @llvm.rint.f32(float %Val)
10345 declare double @llvm.rint.f64(double %Val)
10346 declare x86_fp80 @llvm.rint.f80(x86_fp80 %Val)
10347 declare fp128 @llvm.rint.f128(fp128 %Val)
10348 declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %Val)
10353 The '``llvm.rint.*``' intrinsics returns the operand rounded to the
10369 '``llvm.nearbyint.*``' Intrinsic
10375 This is an overloaded intrinsic. You can use ``llvm.nearbyint`` on any
10381 declare float @llvm.nearbyint.f32(float %Val)
10382 declare double @llvm.nearbyint.f64(double %Val)
10383 declare x86_fp80 @llvm.nearbyint.f80(x86_fp80 %Val)
10384 declare fp128 @llvm.nearbyint.f128(fp128 %Val)
10385 declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %Val)
10390 The '``llvm.nearbyint.*``' intrinsics returns the operand rounded to the
10405 '``llvm.round.*``' Intrinsic
10411 This is an overloaded intrinsic. You can use ``llvm.round`` on any
10417 declare float @llvm.round.f32(float %Val)
10418 declare double @llvm.round.f64(double %Val)
10419 declare x86_fp80 @llvm.round.f80(x86_fp80 %Val)
10420 declare fp128 @llvm.round.f128(fp128 %Val)
10421 declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %Val)
10426 The '``llvm.round.*``' intrinsics returns the operand rounded to the
10447 '``llvm.bitreverse.*``' Intrinsics
10458 declare i16 @llvm.bitreverse.i16(i16 <id>)
10459 declare i32 @llvm.bitreverse.i32(i32 <id>)
10460 declare i64 @llvm.bitreverse.i64(i64 <id>)
10465 The '``llvm.bitreverse``' family of intrinsics is used to reverse the
10472 The ``llvm.bitreverse.iN`` intrinsic returns an i16 value that has bit
10475 '``llvm.bswap.*``' Intrinsics
10486 declare i16 @llvm.bswap.i16(i16 <id>)
10487 declare i32 @llvm.bswap.i32(i32 <id>)
10488 declare i64 @llvm.bswap.i64(i64 <id>)
10493 The '``llvm.bswap``' family of intrinsics is used to byte swap integer
10501 The ``llvm.bswap.i16`` intrinsic returns an i16 value that has the high
10502 and low byte of the input i16 swapped. Similarly, the ``llvm.bswap.i32``
10506 ``llvm.bswap.i48``, ``llvm.bswap.i64`` and other intrinsics extend this
10510 '``llvm.ctpop.*``' Intrinsic
10516 This is an overloaded intrinsic. You can use llvm.ctpop on any integer
10522 declare i8 @llvm.ctpop.i8(i8 <src>)
10523 declare i16 @llvm.ctpop.i16(i16 <src>)
10524 declare i32 @llvm.ctpop.i32(i32 <src>)
10525 declare i64 @llvm.ctpop.i64(i64 <src>)
10526 declare i256 @llvm.ctpop.i256(i256 <src>)
10527 declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32> <src>)
10532 The '``llvm.ctpop``' family of intrinsics counts the number of bits set
10545 The '``llvm.ctpop``' intrinsic counts the 1's in a variable, or within
10548 '``llvm.ctlz.*``' Intrinsic
10554 This is an overloaded intrinsic. You can use ``llvm.ctlz`` on any
10560 declare i8 @llvm.ctlz.i8 (i8 <src>, i1 <is_zero_undef>)
10561 declare i16 @llvm.ctlz.i16 (i16 <src>, i1 <is_zero_undef>)
10562 declare i32 @llvm.ctlz.i32 (i32 <src>, i1 <is_zero_undef>)
10563 declare i64 @llvm.ctlz.i64 (i64 <src>, i1 <is_zero_undef>)
10564 declare i256 @llvm.ctlz.i256(i256 <src>, i1 <is_zero_undef>)
10565 declase <2 x i32> @llvm.ctlz.v2i32(<2 x i32> <src>, i1 <is_zero_undef>)
10570 The '``llvm.ctlz``' family of intrinsic functions counts the number of
10589 The '``llvm.ctlz``' intrinsic counts the leading (most significant)
10593 ``llvm.ctlz(i32 2) = 30``.
10595 '``llvm.cttz.*``' Intrinsic
10601 This is an overloaded intrinsic. You can use ``llvm.cttz`` on any
10607 declare i8 @llvm.cttz.i8 (i8 <src>, i1 <is_zero_undef>)
10608 declare i16 @llvm.cttz.i16 (i16 <src>, i1 <is_zero_undef>)
10609 declare i32 @llvm.cttz.i32 (i32 <src>, i1 <is_zero_undef>)
10610 declare i64 @llvm.cttz.i64 (i64 <src>, i1 <is_zero_undef>)
10611 declare i256 @llvm.cttz.i256(i256 <src>, i1 <is_zero_undef>)
10612 declase <2 x i32> @llvm.cttz.v2i32(<2 x i32> <src>, i1 <is_zero_undef>)
10617 The '``llvm.cttz``' family of intrinsic functions counts the number of
10636 The '``llvm.cttz``' intrinsic counts the trailing (least significant)
10640 ``llvm.cttz(2) = 1``.
10649 '``llvm.sadd.with.overflow.*``' Intrinsics
10655 This is an overloaded intrinsic. You can use ``llvm.sadd.with.overflow``
10660 declare {i16, i1} @llvm.sadd.with.overflow.i16(i16 %a, i16 %b)
10661 declare {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
10662 declare {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 %b)
10667 The '``llvm.sadd.with.overflow``' family of intrinsic functions perform
10683 The '``llvm.sadd.with.overflow``' family of intrinsic functions perform
10692 .. code-block:: llvm
10694 %res = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
10699 '``llvm.uadd.with.overflow.*``' Intrinsics
10705 This is an overloaded intrinsic. You can use ``llvm.uadd.with.overflow``
10710 declare {i16, i1} @llvm.uadd.with.overflow.i16(i16 %a, i16 %b)
10711 declare {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
10712 declare {i64, i1} @llvm.uadd.with.overflow.i64(i64 %a, i64 %b)
10717 The '``llvm.uadd.with.overflow``' family of intrinsic functions perform
10733 The '``llvm.uadd.with.overflow``' family of intrinsic functions perform
10741 .. code-block:: llvm
10743 %res = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
10748 '``llvm.ssub.with.overflow.*``' Intrinsics
10754 This is an overloaded intrinsic. You can use ``llvm.ssub.with.overflow``
10759 declare {i16, i1} @llvm.ssub.with.overflow.i16(i16 %a, i16 %b)
10760 declare {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
10761 declare {i64, i1} @llvm.ssub.with.overflow.i64(i64 %a, i64 %b)
10766 The '``llvm.ssub.with.overflow``' family of intrinsic functions perform
10782 The '``llvm.ssub.with.overflow``' family of intrinsic functions perform
10791 .. code-block:: llvm
10793 %res = call {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
10798 '``llvm.usub.with.overflow.*``' Intrinsics
10804 This is an overloaded intrinsic. You can use ``llvm.usub.with.overflow``
10809 declare {i16, i1} @llvm.usub.with.overflow.i16(i16 %a, i16 %b)
10810 declare {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
10811 declare {i64, i1} @llvm.usub.with.overflow.i64(i64 %a, i64 %b)
10816 The '``llvm.usub.with.overflow``' family of intrinsic functions perform
10832 The '``llvm.usub.with.overflow``' family of intrinsic functions perform
10841 .. code-block:: llvm
10843 %res = call {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
10848 '``llvm.smul.with.overflow.*``' Intrinsics
10854 This is an overloaded intrinsic. You can use ``llvm.smul.with.overflow``
10859 declare {i16, i1} @llvm.smul.with.overflow.i16(i16 %a, i16 %b)
10860 declare {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
10861 declare {i64, i1} @llvm.smul.with.overflow.i64(i64 %a, i64 %b)
10866 The '``llvm.smul.with.overflow``' family of intrinsic functions perform
10882 The '``llvm.smul.with.overflow``' family of intrinsic functions perform
10891 .. code-block:: llvm
10893 %res = call {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
10898 '``llvm.umul.with.overflow.*``' Intrinsics
10904 This is an overloaded intrinsic. You can use ``llvm.umul.with.overflow``
10909 declare {i16, i1} @llvm.umul.with.overflow.i16(i16 %a, i16 %b)
10910 declare {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
10911 declare {i64, i1} @llvm.umul.with.overflow.i64(i64 %a, i64 %b)
10916 The '``llvm.umul.with.overflow``' family of intrinsic functions perform
10932 The '``llvm.umul.with.overflow``' family of intrinsic functions perform
10941 .. code-block:: llvm
10943 %res = call {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
10951 '``llvm.canonicalize.*``' Intrinsic
10959 declare float @llvm.canonicalize.f32(float %a)
10960 declare double @llvm.canonicalize.f64(double %b)
10965 The '``llvm.canonicalize.*``' intrinsic returns the platform specific canonical
10996 1.0 and ``llvm.minnum(x, x)`` are possible implementations. Addition with
10997 -0.0 is also sufficient provided that the rounding mode is not -Infinity.
10999 ``@llvm.canonicalize`` must preserve the equality relation. That is:
11001 - ``(@llvm.canonicalize(x) == x)`` is equivalent to ``(x == x)``
11002 - ``(@llvm.canonicalize(x) == @llvm.canonicalize(y))`` is equivalent to
11006 ``@llvm.canonicalize(-0.0) = -0.0`` and ``@llvm.canonicalize(+0.0) = +0.0``
11020 '``llvm.fmuladd.*``' Intrinsic
11028 declare float @llvm.fmuladd.f32(float %a, float %b, float %c)
11029 declare double @llvm.fmuladd.f64(double %a, double %b, double %c)
11034 The '``llvm.fmuladd.*``' intrinsic functions represent multiply-add
11043 The '``llvm.fmuladd.*``' intrinsics each take three arguments: two
11053 %0 = call float @llvm.fmuladd.f32(%a, %b, %c)
11059 corresponding llvm.fma.\* intrinsic function should be used
11060 instead. This never sets errno, just as '``llvm.fma.*``'.
11065 .. code-block:: llvm
11067 … %r2 = call float @llvm.fmuladd.f32(float %a, float %b, float %c) ; yields float:r2 = (a * b) + c
11078 :ref:`llvm.convert.from.fp16 <int_convert_from_fp16>`. Computation can
11082 :ref:`llvm.convert.to.fp16 <int_convert_to_fp16>`, then storing as an
11087 '``llvm.convert.to.fp16``' Intrinsic
11095 declare i16 @llvm.convert.to.fp16.f32(float %a)
11096 declare i16 @llvm.convert.to.fp16.f64(double %a)
11101 The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
11113 The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
11120 .. code-block:: llvm
11122 %res = call i16 @llvm.convert.to.fp16.f32(float %a)
11127 '``llvm.convert.from.fp16``' Intrinsic
11135 declare float @llvm.convert.from.fp16.f32(i16 %a)
11136 declare double @llvm.convert.from.fp16.f64(i16 %a)
11141 The '``llvm.convert.from.fp16``' intrinsic function performs a
11154 The '``llvm.convert.from.fp16``' intrinsic function performs a
11162 .. code-block:: llvm
11165 %res = call float @llvm.convert.from.fp16(i16 %a)
11172 The LLVM debugger intrinsics (which all start with ``llvm.dbg.``
11181 ``llvm.eh.`` prefix), are described in the `LLVM Exception
11202 .. code-block:: llvm
11206 …call i8* @llvm.init.trampoline(i8* %tramp1, i8* bitcast (i32 (i8*, i32, i32)* @f to i8*), i8* %nva…
11207 %p = call i8* @llvm.adjust.trampoline(i8* %tramp1)
11215 '``llvm.init.trampoline``' Intrinsic
11223 declare void @llvm.init.trampoline(i8* <tramp>, i8* <func>, i8* <nval>)
11234 The ``llvm.init.trampoline`` intrinsic takes three arguments, all
11248 passed to :ref:`llvm.adjust.trampoline <int_at>` to get a pointer which can
11255 calling ``llvm.init.trampoline``, the memory pointed to by ``tramp`` is
11261 '``llvm.adjust.trampoline``' Intrinsic
11269 declare i8* @llvm.adjust.trampoline(i8* <tramp>)
11282 :ref:`llvm.init.trampoline <int_it>`.
11302 '``llvm.masked.load.*``' Intrinsics
11311 …declare <16 x float> @llvm.masked.load.v16f32 (<16 x float>* <ptr>, i32 <alignment>, <16 x i1> <m…
11312 …declare <2 x double> @llvm.masked.load.v2f64 (<2 x double>* <ptr>, i32 <alignment>, <2 x i1> <m…
11314 …declare <8 x double*> @llvm.masked.load.v8p0f64 (<8 x double*>* <ptr>, i32 <alignment>, <8 x i1…
11316 …declare <8 x i32 ()*> @llvm.masked.load.v8p0f_i32f (<8 x i32 ()*>* <ptr>, i32 <alignment>, <8 x i1…
11333 The '``llvm.masked.load``' intrinsic is designed for conditional reading of selected vector element…
11339 …%res = call <16 x float> @llvm.masked.load.v16f32 (<16 x float>* %ptr, i32 4, <16 x i1>%mask, <16 …
11347 '``llvm.masked.store.*``' Intrinsics
11356 …declare void @llvm.masked.store.v8i32 (<8 x i32> <value>, <8 x i32>* <ptr>, i32 <alignment>…
11357 …declare void @llvm.masked.store.v16f32 (<16 x float> <value>, <16 x float>* <ptr>, i32 <alignment>…
11359 …declare void @llvm.masked.store.v8p0f64 (<8 x double*> <value>, <8 x double*>* <ptr>, i32 <alig…
11361 …declare void @llvm.masked.store.v4p0f_i32f (<4 x i32 ()*> <value>, <4 x i32 ()*>* <ptr>, i32 <alig…
11377 The '``llvm.masked.store``' intrinsics is designed for conditional writing of selected vector eleme…
11382 …call void @llvm.masked.store.v16f32(<16 x float> %value, <16 x float>* %ptr, i32 4, <16 x i1> %ma…
11397 '``llvm.masked.gather.*``' Intrinsics
11406 …declare <16 x float> @llvm.masked.gather.v16f32 (<16 x float*> <ptrs>, i32 <alignment>, <16 x i1…
11407 …declare <2 x double> @llvm.masked.gather.v2f64 (<2 x double*> <ptrs>, i32 <alignment>, <2 x i1>…
11408 …declare <8 x float*> @llvm.masked.gather.v8p0f32 (<8 x float**> <ptrs>, i32 <alignment>, <8 x i1>…
11425 The '``llvm.masked.gather``' intrinsic is designed for conditional reading of multiple scalar value…
11431 …%res = call <4 x double> @llvm.masked.gather.v4f64 (<4 x double*> %ptrs, i32 8, <4 x i1>%mask, <4 …
11451 '``llvm.masked.scatter.*``' Intrinsics
11460 …declare void @llvm.masked.scatter.v8i32 (<8 x i32> <value>, <8 x i32*> <ptrs>, i32 <alig…
11461 …declare void @llvm.masked.scatter.v16f32 (<16 x float> <value>, <16 x float*> <ptrs>, i32 <alig…
11462 …declare void @llvm.masked.scatter.v4p0f64 (<4 x double*> <value>, <4 x double**> <ptrs>, i32 <alig…
11478 The '``llvm.masked.scatter``' intrinsics is designed for writing selected vector elements to arbitr…
11483 …call @llvm.masked.scatter.v8i32 (<8 x i32> %value, <8 x i32*> %ptrs, i32 4, <8 x i1> <true, true…
11509 '``llvm.lifetime.start``' Intrinsic
11517 declare void @llvm.lifetime.start(i64 <size>, i8* nocapture <ptr>)
11522 The '``llvm.lifetime.start``' intrinsic specifies the start of a memory
11542 '``llvm.lifetime.end``' Intrinsic
11550 declare void @llvm.lifetime.end(i64 <size>, i8* nocapture <ptr>)
11555 The '``llvm.lifetime.end``' intrinsic specifies the end of a memory
11573 '``llvm.invariant.start``' Intrinsic
11581 declare {}* @llvm.invariant.start(i64 <size>, i8* nocapture <ptr>)
11586 The '``llvm.invariant.start``' intrinsic specifies that the contents of
11599 This intrinsic indicates that until an ``llvm.invariant.end`` that uses
11603 '``llvm.invariant.end``' Intrinsic
11611 declare void @llvm.invariant.end({}* <start>, i64 <size>, i8* nocapture <ptr>)
11616 The '``llvm.invariant.end``' intrinsic specifies that the contents of a
11622 The first argument is the matching ``llvm.invariant.start`` intrinsic.
11632 '``llvm.invariant.group.barrier``' Intrinsic
11640 declare i8* @llvm.invariant.group.barrier(i8* <ptr>)
11645 The '``llvm.invariant.group.barrier``' intrinsic can be used when an invariant
11653 The ``llvm.invariant.group.barrier`` takes only one argument, which is
11668 '``llvm.var.annotation``' Intrinsic
11676 declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int>)
11681 The '``llvm.var.annotation``' intrinsic.
11698 '``llvm.ptr.annotation.*``' Intrinsic
11704 This is an overloaded intrinsic. You can use '``llvm.ptr.annotation``' on a
11711 … declare i8* @llvm.ptr.annotation.p<address space>i8(i8* <val>, i8* <str>, i8* <str>, i32 <int>)
11712 …declare i16* @llvm.ptr.annotation.p<address space>i16(i16* <val>, i8* <str>, i8* <str>, i32 <int…
11713 …declare i32* @llvm.ptr.annotation.p<address space>i32(i32* <val>, i8* <str>, i8* <str>, i32 <int…
11714 …declare i64* @llvm.ptr.annotation.p<address space>i64(i64* <val>, i8* <str>, i8* <str>, i32 <int…
11715 …declare i256* @llvm.ptr.annotation.p<address space>i256(i256* <val>, i8* <str>, i8* <str>, i32 <i…
11720 The '``llvm.ptr.annotation``' intrinsic.
11738 '``llvm.annotation.*``' Intrinsic
11744 This is an overloaded intrinsic. You can use '``llvm.annotation``' on
11749 declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32 <int>)
11750 declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32 <int>)
11751 declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32 <int>)
11752 declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32 <int>)
11753 declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32 <int>)
11758 The '``llvm.annotation``' intrinsic.
11776 '``llvm.trap``' Intrinsic
11784 declare void @llvm.trap() noreturn nounwind
11789 The '``llvm.trap``' intrinsic.
11803 '``llvm.debugtrap``' Intrinsic
11811 declare void @llvm.debugtrap() nounwind
11816 The '``llvm.debugtrap``' intrinsic.
11830 '``llvm.stackprotector``' Intrinsic
11838 declare void @llvm.stackprotector(i8* <guard>, i8** <slot>)
11843 The ``llvm.stackprotector`` intrinsic takes the ``guard`` and stores it
11850 The ``llvm.stackprotector`` intrinsic requires two pointer arguments.
11862 checked against the original guard by ``llvm.stackprotectorcheck``. If they are
11863 different, then ``llvm.stackprotectorcheck`` causes the program to abort by
11866 '``llvm.stackprotectorcheck``' Intrinsic
11874 declare void @llvm.stackprotectorcheck(i8** <guard>)
11879 The ``llvm.stackprotectorcheck`` intrinsic compares ``guard`` against an already
11886 The ``llvm.stackprotectorcheck`` intrinsic requires one pointer argument, the
11893 ``guard`` with the stack slot created by ``llvm.stackprotector`` and if the
11904 '``llvm.objectsize``' Intrinsic
11912 declare i32 @llvm.objectsize.i32(i8* <object>, i1 <min>)
11913 declare i64 @llvm.objectsize.i64(i8* <object>, i1 <min>)
11918 The ``llvm.objectsize`` intrinsic is designed to provide information to
11928 The ``llvm.objectsize`` intrinsic takes two arguments. The first
11930 a boolean and determines whether ``llvm.objectsize`` returns 0 (if true)
11937 The ``llvm.objectsize`` intrinsic is lowered to a constant representing
11939 compile time, ``llvm.objectsize`` returns ``i32/i64 -1 or 0`` (depending
11942 '``llvm.expect``' Intrinsic
11948 This is an overloaded intrinsic. You can use ``llvm.expect`` on any
11953 declare i1 @llvm.expect.i1(i1 <val>, i1 <expected_val>)
11954 declare i32 @llvm.expect.i32(i32 <val>, i32 <expected_val>)
11955 declare i64 @llvm.expect.i64(i64 <val>, i64 <expected_val>)
11960 The ``llvm.expect`` intrinsic provides information about expected (the
11966 The ``llvm.expect`` intrinsic takes two arguments. The first argument is
11977 '``llvm.assume``' Intrinsic
11985 declare void @llvm.assume(i1 %cond)
11990 The ``llvm.assume`` allows the optimizer to assume that the provided
12009 used by the ``llvm.assume`` intrinsic in order to preserve the instructions
12011 if the extra information provided by the ``llvm.assume`` intrinsic does not cause
12013 ``llvm.assume`` should not be used to document basic mathematical invariants
12019 '``llvm.bitset.test``' Intrinsic
12027 declare i1 @llvm.bitset.test(i8* %ptr, metadata %bitset) nounwind readnone
12039 The ``llvm.bitset.test`` intrinsic tests whether the given pointer is a
12042 '``llvm.donothing``' Intrinsic
12050 declare void @llvm.donothing() nounwind readnone
12055 The ``llvm.donothing`` intrinsic doesn't perform any operation. It's one of only
12056 two intrinsics (besides ``llvm.experimental.patchpoint``) that can be called