diff options
Diffstat (limited to 'llvm/docs/LangRef.rst')
| -rw-r--r-- | llvm/docs/LangRef.rst | 46 |
1 files changed, 33 insertions, 13 deletions
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst index b32a27f..8e86393 100644 --- a/llvm/docs/LangRef.rst +++ b/llvm/docs/LangRef.rst @@ -3013,6 +3013,8 @@ assumptions, such as that a :ref:`parameter attribute <paramattrs>` or a location. Operand bundles enable assumptions that are either hard or impossible to represent as a boolean argument of an :ref:`llvm.assume <int_assume>`. +Assumes with operand bundles must have ``i1 true`` as the condition operand. + An assume operand bundle has the form: :: @@ -3045,7 +3047,7 @@ allows the optimizer to assume that at location of call to .. code-block:: llvm - call void @llvm.assume(i1 %cond) ["cold"(), "nonnull"(ptr %val)] + call void @llvm.assume(i1 true) ["cold"(), "nonnull"(ptr %val)] allows the optimizer to assume that the :ref:`llvm.assume <int_assume>` call location is cold and that ``%val`` may not be null. @@ -8862,6 +8864,28 @@ For example, the following metadata section contains two library specifiers:: Each library specifier will be handled independently by the consuming linker. The effect of the library specifiers are defined by the consuming linker. +'``llvm.errno.tbaa``' Named Metadata +==================================== + +The module-level ``!llvm.errno.tbaa`` metadata specifies the TBAA nodes used +for accessing ``errno``. These nodes are guaranteed to represent int-compatible +accesses according to C/C++ strict aliasing rules. This should let LLVM alias +analyses to reason about aliasing with ``errno`` when calling library functions +that may set ``errno``, allowing optimizations such as store-to-load forwarding +across such routines. + +For example, the following is a valid metadata specifying the TBAA information +for an integer access: + + !llvm.errno.tbaa = !{!0} + !0 = !{!1, !1, i64 0} + !1 = !{!"int", !2, i64 0} + !2 = !{!"omnipotent char", !3, i64 0} + !3 = !{!"Simple C/C++ TBAA"} + +Multiple TBAA operands are allowed to support merging of modules that may use +different TBAA hierarchies (e.g., when mixing C and C++). + .. _summary: ThinLTO Summary @@ -11397,11 +11421,9 @@ responsibility of the code emitter to ensure that the alignment information is correct. Overestimating the alignment results in undefined behavior. Underestimating the alignment may produce less efficient code. An alignment of 1 is always safe. The maximum possible alignment is ``1 << 32``. An alignment -value higher than the size of the loaded type implies memory up to the -alignment value bytes can be safely loaded without trapping in the default -address space. Access of the high bytes can interfere with debugging tools, so -should not be accessed if the function has the ``sanitize_thread`` or -``sanitize_address`` attributes. +value higher than the size of the loaded type does *not* imply (without target +specific knowledge) that memory up to the alignment value bytes can be safely +loaded without trapping. The alignment is only optional when parsing textual IR; for in-memory IR, it is always present. An omitted ``align`` argument means that the operation has the @@ -11537,12 +11559,10 @@ operation (that is, the alignment of the memory address). It is the responsibility of the code emitter to ensure that the alignment information is correct. Overestimating the alignment results in undefined behavior. Underestimating the alignment may produce less efficient code. An alignment of -1 is always safe. The maximum possible alignment is ``1 << 32``. An alignment -value higher than the size of the loaded type implies memory up to the -alignment value bytes can be safely loaded without trapping in the default -address space. Access of the high bytes can interfere with debugging tools, so -should not be accessed if the function has the ``sanitize_thread`` or -``sanitize_address`` attributes. +1 is always safe. The maximum possible alignment is ``1 << 32``. An alignment +value higher than the size of the stored type does *not* imply (without target +specific knowledge) that memory up to the alignment value bytes can be safely +loaded without trapping. The alignment is only optional when parsing textual IR; for in-memory IR, it is always present. An omitted ``align`` argument means that the operation has the @@ -24566,7 +24586,7 @@ Overview: The '``llvm.vp.load.ff.*``' intrinsic is similar to '``llvm.vp.load.*``', but will not trap if there are not ``evl`` readable -lanes at the pointer. '``ff``' stands for fault-first or fault-only-first. +lanes at the pointer. '``ff``' stands for first-fault or fault-only-first. Arguments: """""""""" |