[LangRef] Update for opaque pointers (NFC)

[nikic]

Summary

Update LangRef examples to use opaque pointers in most places. I've retained typed pointers in a few cases where opaque pointers don't make much sense, e.g. pointer to pointer bitcasts.

llvm/docs/LangRef.rst

 symbol table entries. Here is an example of the "hello world" module:
 
 .. code-block:: llvm
 
     ; Declare the string constant as a global constant.
     @.str = private unnamed_addr constant [13 x i8] c"hello world\0A\00"
 
     ; External declaration of the puts function
-    declare i32 @puts(i8* nocapture) nounwind
+    declare i32 @puts(ptr nocapture) nounwind
 
     ; Definition of main function
-    define i32 @main() {   ; i32()*
-      ; Convert [13 x i8]* to i8*...
-      %cast210 = getelementptr [13 x i8], [13 x i8]* @.str, i64 0, i64 0
-
+    define i32 @main() {
       ; Call puts function to write out the string to stdout.
-      call i32 @puts(i8* %cast210)
+      call i32 @puts(ptr @.str)
       ret i32 0
     }
 
     ; Named metadata
     !0 = !{i32 42, null, !"string"}
     !foo = !{!0}
 
 This example is made up of a :ref:`global variable <globalvars>` named

 parameter attributes can have the same function type.
 
 Parameter attributes are simple keywords that follow the type specified.
 If multiple parameter attributes are needed, they are space separated.
 For example:
 
 .. code-block:: llvm
 
-    declare i32 @printf(i8* noalias nocapture, ...)
+    declare i32 @printf(ptr noalias nocapture, ...)
     declare i32 @atoi(i8 zeroext)
     declare signext i8 @returns_signed_char()
 
 Note that any attributes for the function result (``nounwind``,
 ``readonly``) come immediately after the argument list.
 
 Currently, only the following parameter attributes are defined:
 
``nocapture``
     pointer. This is not a valid attribute for return values.
     This attribute applies only to the particular copy of the pointer passed in
     this argument. A caller could pass two copies of the same pointer with one
     being annotated nocapture and the other not, and the callee could validly
     capture through the non annotated parameter.
 
 .. code-block:: llvm
 
-    define void @f(i8* nocapture %a, i8* %b) {
+    define void @f(ptr nocapture %a, ptr %b) {
       ; (capture %b)
     }
 
-    call void @f(i8* @glb, i8* @glb) ; well-defined
+    call void @f(ptr @glb, ptr @glb) ; well-defined
 
 ``nofree``
     This indicates that callee does not free the pointer argument. This is not
     a valid attribute for return values.
 
 .. _nest:
 
 ``nest``

 .. code-block:: llvm
 
     define void @f() prefix i32 123 { ... }
 
 The prefix data can be referenced as,
 
 .. code-block:: llvm
 
-    %0 = bitcast void* () @f to i32*
-    %a = getelementptr inbounds i32, i32* %0, i32 -1
-    %b = load i32, i32* %a
+    %a = getelementptr inbounds i32, ptr @f, i32 -1
+    %b = load i32, ptr %a
 
 Prefix data is laid out as if it were an initializer for a global variable
 of the prefix data's type. The function will be placed such that the
 beginning of the prefix data is aligned. This means that if the size
 of the prefix data is not a multiple of the alignment size, the
 function's entrypoint will not be aligned. If alignment of the
 function's entrypoint is desired, padding must be added to the prefix
 data.
.. code-block:: text
     define void @f() prologue i8 144 { ... }
 
 Generally prologue data can be formed by encoding a relative branch instruction
 which skips the metadata, as in this example of valid prologue data for the
 x86_64 architecture, where the first two bytes encode ``jmp .+10``:
 
 .. code-block:: text
 
-    %0 = type <{ i8, i8, i8* }>
+    %0 = type <{ i8, i8, ptr }>
 
-    define void @f() prologue %0 <{ i8 235, i8 8, i8* @md}> { ... }
+    define void @f() prologue %0 <{ i8 235, i8 8, ptr @md}> { ... }
 
 A function may have prologue data but no body. This has similar semantics
 to the ``available_externally`` linkage in that the data may be used by the
 optimizers but will not be emitted in the object file.
 
 .. _personalityfn:
 
 Personality Function

 continuation to every deoptimization continuation in the inlined body.
 E.g. inlining ``@f`` into ``@g`` in the following example
 
 .. code-block:: llvm
 
     define void @f() {
       call void @x()  ;; no deopt state
       call void @y() [ "deopt"(i32 10) ]
-      call void @y() [ "deopt"(i32 10), "unknown"(i8* null) ]
+      call void @y() [ "deopt"(i32 10), "unknown"(ptr null) ]
       ret void
     }
 
     define void @g() {
       call void @f() [ "deopt"(i32 20) ]
       ret void
     }
 
 will result in
 
 .. code-block:: llvm
 
     define void @g() {
       call void @x()  ;; still no deopt state
       call void @y() [ "deopt"(i32 20, i32 10) ]
-      call void @y() [ "deopt"(i32 20, i32 10), "unknown"(i8* null) ]
+      call void @y() [ "deopt"(i32 20, i32 10), "unknown"(ptr null) ]
       ret void
     }
 
 It is the frontend's responsibility to structure or encode the
 deoptimization state in a way that syntactically prepending the
 caller's deoptimization state to the callee's deoptimization state is
 semantically equivalent to composing the caller's deoptimization
 continuation after the callee's deoptimization continuation.

 * The second argument if present is an argument of the attribute.
 
 If there are no arguments the attribute is a property of the call location.
 
 For example:
 
 .. code-block:: llvm
 
-      call void @llvm.assume(i1 true) ["align"(i32* %val, i32 8)]
+      call void @llvm.assume(i1 true) ["align"(ptr %val, i32 8)]
 
 allows the optimizer to assume that at location of call to
 :ref:`llvm.assume <int_assume>` ``%val`` has an alignment of at least 8.
 
 .. code-block:: llvm
 
-      call void @llvm.assume(i1 %cond) ["cold"(), "nonnull"(i64* %val)]
+      call void @llvm.assume(i1 %cond) ["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.
 
 Just like for the argument of :ref:`llvm.assume <int_assume>`, if any of the
 provided guarantees are violated at runtime the behavior is undefined.
 
 While attributes expect constant arguments, assume operand bundles may be
 provided a dynamic value, for example:
 
 .. code-block:: llvm
 
-      call void @llvm.assume(i1 true) ["align"(i32* %val, i32 %align)]
+      call void @llvm.assume(i1 true) ["align"(ptr %val, i32 %align)]
 
 If the operand bundle value violates any requirements on the attribute value,
 the behavior is undefined, unless one of the following exceptions applies:
 
 * ``"assume"`` operand bundles may specify a non-power-of-two alignment
   (including a zero alignment). If this is the case, then the pointer value
   must be a null pointer, otherwise the behavior is undefined.
 
 Even if the assumed property can be encoded as a boolean value, like
 ``nonnull``, using operand bundles to express the property can still have
 benefits:
 
 * Attributes that can be expressed via operand bundles are directly the
   property that the optimizer uses and cares about. Encoding attributes as
   operand bundles removes the need for an instruction sequence that represents
-  the property (e.g., `icmp ne i32* %p, null` for `nonnull`) and for the
+  the property (e.g., `icmp ne ptr %p, null` for `nonnull`) and for the
   optimizer to deduce the property from that instruction sequence.
 * Expressing the property using operand bundles makes it easy to identify the
   use of the value as a use in an :ref:`llvm.assume <int_assume>`. This then
   simplifies and improves heuristics, e.g., for use "use-sensitive"
   optimizations.
 
 .. _ob_preallocated:
 

 
 .. code-block:: llvm
 
       %foo = type { i64, i32 }
 
       ...
 
       %t = call token @llvm.call.preallocated.setup(i32 1)
-      %a = call i8* @llvm.call.preallocated.arg(token %t, i32 0) preallocated(%foo)
-      %b = bitcast i8* %a to %foo*
+      %a = call ptr @llvm.call.preallocated.arg(token %t, i32 0) preallocated(%foo)
       ; initialize %b
-      call void @bar(i32 42, %foo* preallocated(%foo) %b) ["preallocated"(token %t)]
+      call void @bar(i32 42, ptr preallocated(%foo) %a) ["preallocated"(token %t)]
 
 .. _ob_gc_live:
 
 GC Live Operand Bundles
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A "gc-live" operand bundle is only valid on a :ref:`gc.statepoint <gc_statepoint>`
 intrinsic. The operand bundle must contain every pointer to a garbage collected

 The return value of a call with this bundle is used by a call to
 ``@llvm.objc.clang.arc.noop.use`` unless the called function's return type is
 void, in which case the operand bundle is ignored.
 
 .. code-block:: llvm
 
    ; The marker instruction and a runtime function call are inserted after the call
    ; to @foo.
-   call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
-   call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_unsafeClaimAutoreleasedReturnValue) ]
+   call ptr @foo() [ "clang.arc.attachedcall"(ptr @objc_retainAutoreleasedReturnValue) ]
+   call ptr @foo() [ "clang.arc.attachedcall"(ptr @objc_unsafeClaimAutoreleasedReturnValue) ]
 
 The operand bundle is needed to ensure the call is immediately followed by the
 marker instruction and the ObjC runtime call in the final output.
 
 .. _ob_ptrauth:
 
 Pointer Authentication Operand Bundles
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 hold:
 
 1. The call stores any bit of the pointer carrying information into a place,
    and the stored bits can be read from the place by the caller after this call
    exits.
 
 .. code-block:: llvm
 
-    @glb  = global i8* null
-    @glb2 = global i8* null
-    @glb3 = global i8* null
+    @glb  = global ptr null
+    @glb2 = global ptr null
+    @glb3 = global ptr null
     @glbi = global i32 0
 
-    define i8* @f(i8* %a, i8* %b, i8* %c, i8* %d, i8* %e) {
-      store i8* %a, i8** @glb ; %a is captured by this call
+    define ptr @f(ptr %a, ptr %b, ptr %c, ptr %d, ptr %e) {
+      store ptr %a, ptr @glb ; %a is captured by this call
 
-      store i8* %b,   i8** @glb2 ; %b isn't captured because the stored value is overwritten by the store below
-      store i8* null, i8** @glb2
+      store ptr %b,   ptr @glb2 ; %b isn't captured because the stored value is overwritten by the store below
+      store ptr null, ptr @glb2
 
-      store i8* %c,   i8** @glb3
+      store ptr %c,   ptr @glb3
       call void @g() ; If @g makes a copy of %c that outlives this call (@f), %c is captured
-      store i8* null, i8** @glb3
+      store ptr null, ptr @glb3
 
-      %i = ptrtoint i8* %d to i64
+      %i = ptrtoint ptr %d to i64
       %j = trunc i64 %i to i32
-      store i32 %j, i32* @glbi ; %d is captured
+      store i32 %j, ptr @glbi ; %d is captured
 
-      ret i8* %e ; %e is captured
+      ret ptr %e ; %e is captured
     }
 
 2. The call stores any bit of the pointer carrying information into a place,
    and the stored bits can be safely read from the place by another thread via
    synchronization.
 
 .. code-block:: llvm
 
     @lock = global i1 true
 
-    define void @f(i8* %a) {
-      store i8* %a, i8** @glb
-      store atomic i1 false, i1* @lock release ; %a is captured because another thread can safely read @glb
-      store i8* null, i8** @glb
+    define void @f(ptr %a) {
+      store ptr %a, ptr* @glb
+      store atomic i1 false, ptr @lock release ; %a is captured because another thread can safely read @glb
+      store ptr null, ptr @glb
       ret void
     }
 
 3. The call's behavior depends on any bit of the pointer carrying information.
 
 .. code-block:: llvm
 
     @glb = global i8 0
 
-    define void @f(i8* %a) {
-      %c = icmp eq i8* %a, @glb
+    define void @f(ptr %a) {
+      %c = icmp eq ptr %a, @glb
       br i1 %c, label %BB_EXIT, label %BB_CONTINUE ; escapes %a
     BB_EXIT:
       call void @exit()
       unreachable
     BB_CONTINUE:
       ret void
     }
 
bb:
       ; ... instructions ...
 
       ; At function scope.
       uselistorder i32 %arg1, { 1, 0, 2 }
       uselistorder label %bb, { 1, 0 }
     }
 
     ; At global scope.
-    uselistorder i32* @global, { 1, 2, 0 }
+    uselistorder ptr @global, { 1, 2, 0 }
     uselistorder i32 7, { 1, 0 }
     uselistorder i32 (i32) @bar, { 1, 0 }
     uselistorder_bb @foo, %bb, { 5, 1, 3, 2, 0, 4 }
 
 .. _source_filename:
 
 Source Filename
 ---------------

 handling intrinsic <int_varargs>` functions. '``<returntype>``' is any type
 except :ref:`label <t_label>` and :ref:`metadata <t_metadata>`.
 
 :Examples:
 
 +---------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``i32 (i32)``                   | function taking an ``i32``, returning an ``i32``                                                                                                                    |
 +---------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| ``float (i16, i32 *) *``        | :ref:`Pointer <t_pointer>` to a function that takes an ``i16`` and a :ref:`pointer <t_pointer>` to ``i32``, returning ``float``.                                    |
-+---------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| ``i32 (i8*, ...)``              | A vararg function that takes at least one :ref:`pointer <t_pointer>` to ``i8`` (char in C), which returns an integer. This is the signature for ``printf`` in LLVM. |
+| ``i32 (ptr, ...)``              | A vararg function that takes at least one :ref:`pointer <t_pointer>` argument and returns an integer. This is the signature for ``printf`` in LLVM. |
 +---------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``{i32, i32} (i32)``            | A function taking an ``i32``, returning a :ref:`structure <t_struct>` containing two ``i32`` values                                                                 |
 +---------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 .. _t_firstclass:
 
 First Class Types
 -----------------

 .. code-block:: llvm
 
       %val = bitcast <4 x i4> <i4 1, i4 2, i4 3, i4 5> to i16
 
       ; Bitcasting from a vector to an integral type can be seen as
       ; concatenating the values:
       ;   %val now has the hexadecimal value 0x1235.
 
-      store i16 %val, i16* %ptr
+      store i16 %val, ptr %ptr
 
       ; In memory the content will be (8-bit addressing):
       ;
       ;    [%ptr + 0]: 00010010  (0x12)
       ;    [%ptr + 1]: 00110101  (0x35)
 
 The same example for little endian:
 
 .. code-block:: llvm
 
       %val = bitcast <4 x i4> <i4 1, i4 2, i4 3, i4 5> to i16
 
       ; Bitcasting from a vector to an integral type can be seen as
       ; concatenating the values:
       ;   %val now has the hexadecimal value 0x5321.
 
-      store i16 %val, i16* %ptr
+      store i16 %val, ptr %ptr
 
       ; In memory the content will be (8-bit addressing):
       ;
       ;    [%ptr + 0]: 01010011  (0x53)
       ;    [%ptr + 1]: 00100001  (0x21)
 
 When ``<N*M>`` isn't evenly divisible by the byte size the exact memory layout
 is unspecified (just like it is for an integral type of the same size). This

 
 +------------------------+----------------------------------------------------+
 | ``<4 x i32>``          | Vector of 4 32-bit integer values.                 |
 +------------------------+----------------------------------------------------+
 | ``<8 x float>``        | Vector of 8 32-bit floating-point values.          |
 +------------------------+----------------------------------------------------+
 | ``<2 x i64>``          | Vector of 2 64-bit integer values.                 |
 +------------------------+----------------------------------------------------+
-| ``<4 x i64*>``         | Vector of 4 pointers to 64-bit integer values.     |
+| ``<4 x ptr>``          | Vector of 4 pointers                               |
 +------------------------+----------------------------------------------------+
 | ``<vscale x 4 x i32>`` | Vector with a multiple of 4 32-bit integer values. |
 +------------------------+----------------------------------------------------+
 
 .. _t_label:
 
 Label Type
 ^^^^^^^^^^

 
 Structures may optionally be "packed" structures, which indicate that
 the alignment of the struct is one byte, and that there is no padding
 between the elements. In non-packed structs, padding between field types
 is inserted as defined by the DataLayout string in the module, which is
 required to match what the underlying code generator expects.
 
 Structures can either be "literal" or "identified". A literal structure
-is defined inline with other types (e.g. ``{i32, i32}*``) whereas
+is defined inline with other types (e.g. ``[2 x {i32, i32}]``) whereas
 identified types are always defined at the top level with a name.
 Literal types are uniqued by their contents and can never be recursive
 or opaque since there is no way to write one. Identified types can be
 recursive, can be opaqued, and are never uniqued.
 
 :Syntax:
 
 ::
 
       %T1 = type { <type list> }     ; Identified normal struct type
       %T2 = type <{ <type list> }>   ; Identified packed struct type
 
 :Examples:
 
 +------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``{ i32, i32, i32 }``        | A triple of three ``i32`` values                                                                                                                                                      |
 +------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| ``{ float, i32 (i32) * }``   | A pair, where the first element is a ``float`` and the second element is a :ref:`pointer <t_pointer>` to a :ref:`function <t_function>` that takes an ``i32``, returning an ``i32``.  |
+| ``{ float, ptr }``           | A pair, where the first element is a ``float`` and the second element is a :ref:`pointer <t_pointer>`.  |
 +------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``<{ i8, i32 }>``            | A packed struct known to be 5 bytes in size.                                                                                                                                          |
 +------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 .. _t_opaque:
 
 Opaque Structure Types
 """"""""""""""""""""""

 
 Complex constants are a (potentially recursive) combination of simple
 constants and smaller complex constants.
 
 **Structure constants**
     Structure constants are represented with notation similar to
     structure type definitions (a comma separated list of elements,
     surrounded by braces (``{}``)). For example:
-    "``{ i32 4, float 17.0, i32* @G }``", where "``@G``" is declared as
+    "``{ i32 4, float 17.0, ptr @G }``", where "``@G``" is declared as
     "``@G = external global i32``". Structure constants must have
     :ref:`structure type <t_struct>`, and the number and types of elements
     must match those specified by the type.
 **Array constants**
     Array constants are represented with notation similar to array type
     definitions (a comma separated list of elements, surrounded by
     square brackets (``[]``)). For example:
     "``[ i32 42, i32 11, i32 74 ]``". Array constants must have
**Zero initialization**
     The string '``zeroinitializer``' can be used to zero initialize a
     value to zero of *any* type, including scalar and
     :ref:`aggregate <t_aggregate>` types. This is often used to avoid
     having to print large zero initializers (e.g. for large arrays) and
     is always exactly equivalent to using explicit zero initializers.
 **Metadata node**
     A metadata node is a constant tuple without types. For example:
     "``!{!0, !{!2, !0}, !"test"}``". Metadata can reference constant values,
-    for example: "``!{!0, i32 0, i8* @global, i64 (i64)* @function, !"str"}``".
+    for example: "``!{!0, i32 0, ptr @global, ptr @function, !"str"}``".
     Unlike other typed constants that are meant to be interpreted as part of
     the instruction stream, metadata is a place to attach additional
     information such as debug info.
 
 Global Variable and Function Addresses
 --------------------------------------
 
 The addresses of :ref:`global variables <globalvars>` and
 :ref:`functions <functionstructure>` are always implicitly valid
 (link-time) constants. These constants are explicitly referenced when
 the :ref:`identifier for the global <identifiers>` is used and always have
 :ref:`pointer <t_pointer>` type. For example, the following is a legal LLVM
 file:
 
 .. code-block:: llvm
 
     @X = global i32 17
     @Y = global i32 42
-    @Z = global [2 x i32*] [ i32* @X, i32* @Y ]
+    @Z = global [2 x ptr] [ ptr @X, ptr @Y ]
 
 .. _undefvalues:
 
 Undefined Values
 ----------------
 
 The string '``undef``' can be used anywhere a constant is expected, and
 indicates that the user of the value may receive an unspecified

 .. code-block:: llvm
 
     Unsafe:
       br undef, BB1, BB2 ; UB
 
       %X = and i32 undef, 255
       switch %X, label %ret [ .. ] ; UB
 
-      store undef, i8* %ptr
-      %X = load i8* %ptr ; %X is undef
+      store undef, ptr %ptr
+      %X = load ptr %ptr ; %X is undef
       switch i8 %X, label %ret [ .. ] ; UB
 
     Safe:
       %X = or i8 undef, 255 ; always 255
       switch i8 %X, label %ret [ .. ] ; Well-defined
 
       %X = freeze i1 undef
       br %X, BB1, BB2 ; Well-defined (non-deterministic jump)

 Here are some examples:
 
 .. code-block:: llvm
 
     entry:
       %poison = sub nuw i32 0, 1           ; Results in a poison value.
       %poison2 = sub i32 poison, 1         ; Also results in a poison value.
       %still_poison = and i32 %poison, 0   ; 0, but also poison.
-      %poison_yet_again = getelementptr i32, i32* @h, i32 %still_poison
-      store i32 0, i32* %poison_yet_again  ; Undefined behavior due to
+      %poison_yet_again = getelementptr i32, ptr @h, i32 %still_poison
+      store i32 0, ptr %poison_yet_again   ; Undefined behavior due to
                                            ; store to poison.
 
-      store i32 %poison, i32* @g           ; Poison value stored to memory.
-      %poison3 = load i32, i32* @g         ; Poison value loaded back from memory.
+      store i32 %poison, ptr @g            ; Poison value stored to memory.
+      %poison3 = load i32, ptr @g          ; Poison value loaded back from memory.
 
-      %narrowaddr = bitcast i32* @g to i16*
-      %wideaddr = bitcast i32* @g to i64*
-      %poison4 = load i16, i16* %narrowaddr ; Returns a poison value.
-      %poison5 = load i64, i64* %wideaddr   ; Returns a poison value.
+      %poison4 = load i16, ptr @g          ; Returns a poison value.
+      %poison5 = load i64, ptr @g          ; Returns a poison value.
 
       %cmp = icmp slt i32 %poison, 0       ; Returns a poison value.
       br i1 %cmp, label %end, label %end   ; undefined behavior
 
     end:
 
 .. _welldefinedvalues:
 

 Addresses of Basic Blocks
 -------------------------
 
 ``blockaddress(@function, %block)``
 
 The '``blockaddress``' constant computes the address of the specified
 basic block in the specified function.
 
-It always has an ``i8 addrspace(P)*`` type, where ``P`` is the address space
+It always has an ``ptr addrspace(P)`` type, where ``P`` is the address space
 of the function containing ``%block`` (usually ``addrspace(0)``).
 
 Taking the address of the entry block is illegal.
 
 This value only has defined behavior when used as an operand to the
 ':ref:`indirectbr <i_indirectbr>`' or ':ref:`callbr <i_callbr>`'instruction, or
 for comparisons against null. Pointer equality tests between labels addresses
 results in undefined behavior --- though, again, comparison against null is ok,
.. code-block:: llvm
     !4 = !{!4, !1}
 
     ; Some scope lists:
     !5 = !{!4} ; A list containing only scope !4
     !6 = !{!4, !3, !2}
     !7 = !{!3}
 
     ; These two instructions don't alias:
-    %0 = load float, float* %c, align 4, !alias.scope !5
-    store float %0, float* %arrayidx.i, align 4, !noalias !5
+    %0 = load float, ptr %c, align 4, !alias.scope !5
+    store float %0, ptr %arrayidx.i, align 4, !noalias !5
 
     ; These two instructions also don't alias (for domain !1, the set of scopes
     ; in the !alias.scope equals that in the !noalias list):
-    %2 = load float, float* %c, align 4, !alias.scope !5
-    store float %2, float* %arrayidx.i2, align 4, !noalias !6
+    %2 = load float, ptr %c, align 4, !alias.scope !5
+    store float %2, ptr %arrayidx.i2, align 4, !noalias !6
 
     ; These two instructions may alias (for domain !0, the set of scopes in
     ; the !noalias list is not a superset of, or equal to, the scopes in the
     ; !alias.scope list):
-    %2 = load float, float* %c, align 4, !alias.scope !6
-    store float %0, float* %arrayidx.i, align 4, !noalias !7
+    %2 = load float, ptr %c, align 4, !alias.scope !6
+    store float %0, ptr %arrayidx.i, align 4, !noalias !7
 
 '``fpmath``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^
 
 ``fpmath`` metadata may be attached to any instruction of floating-point
 type. It can be used to express the maximum acceptable error in the
 result of that instruction, in ULPs, thus potentially allowing the
 compiler to use a more efficient but less accurate method of computing

 
 In addition, the pairs must be in signed order of the lower bound and
 they must be non-contiguous.
 
 Examples:
 
 .. code-block:: llvm
 
-      %a = load i8, i8* %x, align 1, !range !0 ; Can only be 0 or 1
-      %b = load i8, i8* %y, align 1, !range !1 ; Can only be 255 (-1), 0 or 1
+      %a = load i8, ptr %x, align 1, !range !0 ; Can only be 0 or 1
+      %b = load i8, ptr %y, align 1, !range !1 ; Can only be 255 (-1), 0 or 1
       %c = call i8 @foo(),       !range !2 ; Can only be 0, 1, 3, 4 or 5
       %d = invoke i8 @bar() to label %cont
              unwind label %lpad, !range !3 ; Can only be -2, -1, 3, 4 or 5
     ...
     !0 = !{ i8 0, i8 2 }
     !1 = !{ i8 255, i8 2 }
     !2 = !{ i8 0, i8 2, i8 3, i8 6 }
     !3 = !{ i8 -2, i8 0, i8 3, i8 6 }

 For example, in the code below, the call instruction may only target the
 ``add`` or ``sub`` functions:
 
 .. code-block:: llvm
 
     %result = call i64 %binop(i64 %x, i64 %y), !callees !0
 
     ...
-    !0 = !{i64 (i64, i64)* @add, i64 (i64, i64)* @sub}
+    !0 = !{ptr @add, ptr @sub}
 
 '``callback``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 ``callback`` metadata may be attached to a function declaration, or definition.
 (Call sites are excluded only due to the lack of a use case.) For ease of
 exposition, we'll refer to the function annotated w/ metadata as a broker
 function. The metadata describes how the arguments of a call to the broker are

 broker function (``i64 3``).
 
 .. FIXME why does the llvm-sphinx-docs builder give a highlighting
    error if the below is set to highlight as 'llvm', despite that we
    have misc.highlighting_failure set?
 
 .. code-block:: text
 
-    declare !callback !1 dso_local i32 @pthread_create(i64*, %union.pthread_attr_t*, i8* (i8*)*, i8*)
+    declare !callback !1 dso_local i32 @pthread_create(ptr, ptr, ptr, ptr)
 
     ...
     !2 = !{i64 2, i64 3, i1 false}
     !1 = !{!2}
 
 Another example is shown below. The callback callee is the second argument of
 the ``__kmpc_fork_call`` function (``i64 2``). The callee is given two unknown
 values (each identified by a ``i64 -1``) and afterwards all
 variadic arguments that are passed to the ``__kmpc_fork_call`` call (due to the
 final ``i1 true``).
 
 .. FIXME why does the llvm-sphinx-docs builder give a highlighting
    error if the below is set to highlight as 'llvm', despite that we
    have misc.highlighting_failure set?
 
 .. code-block:: text
 
-    declare !callback !0 dso_local void @__kmpc_fork_call(%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...)
+    declare !callback !0 dso_local void @__kmpc_fork_call(ptr, i32, ptr, ...)
 
     ...
     !1 = !{i64 2, i64 -1, i64 -1, i1 true}
     !0 = !{!1}
 
 '``exclude``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^
 

 potentially accesses memory. It can point to a single distinct metadata
 node, which we call access group. This node represents all memory access
 instructions referring to it via ``llvm.access.group``. When an
 instruction belongs to multiple access groups, it can also point to a
 list of accesses groups, illustrated by the following example.
 
 .. code-block:: llvm
 
-   %val = load i32, i32* %arrayidx, !llvm.access.group !0
+   %val = load i32, ptr %arrayidx, !llvm.access.group !0
    ...
    !0 = !{!1, !2}
    !1 = distinct !{}
    !2 = distinct !{}
 
 It is illegal for the list node to be empty since it might be confused
 with an access group.
 

 Example of a loop that is considered parallel due to its correct use of
 both ``llvm.access.group`` and ``llvm.loop.parallel_accesses``
 metadata types.
 
 .. code-block:: llvm
 
    for.body:
      ...
-     %val0 = load i32, i32* %arrayidx, !llvm.access.group !1
+     %val0 = load i32, ptr %arrayidx, !llvm.access.group !1
      ...
-     store i32 %val0, i32* %arrayidx1, !llvm.access.group !1
+     store i32 %val0, ptr %arrayidx1, !llvm.access.group !1
      ...
      br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
 
    for.end:
    ...
    !0 = distinct !{!0, !{!"llvm.loop.parallel_accesses", !1}}
    !1 = distinct !{}
 
 It is also possible to have nested parallel loops:
 
 .. code-block:: llvm
 
    outer.for.body:
      ...
-     %val1 = load i32, i32* %arrayidx3, !llvm.access.group !4
+     %val1 = load i32, ptr %arrayidx3, !llvm.access.group !4
      ...
      br label %inner.for.body
 
    inner.for.body:
      ...
-     %val0 = load i32, i32* %arrayidx1, !llvm.access.group !3
+     %val0 = load i32, ptr %arrayidx1, !llvm.access.group !3
      ...
-     store i32 %val0, i32* %arrayidx2, !llvm.access.group !3
+     store i32 %val0, ptr %arrayidx2, !llvm.access.group !3
      ...
      br i1 %exitcond, label %inner.for.end, label %inner.for.body, !llvm.loop !1
 
    inner.for.end:
      ...
-     store i32 %val1, i32* %arrayidx4, !llvm.access.group !4
+     store i32 %val1, ptr %arrayidx4, !llvm.access.group !4
      ...
      br i1 %exitcond, label %outer.for.end, label %outer.for.body, !llvm.loop !2
 
    outer.for.end:                                          ; preds = %for.body
    ...
    !1 = distinct !{!1, !{!"llvm.loop.parallel_accesses", !3}}     ; metadata for the inner loop
    !2 = distinct !{!2, !{!"llvm.loop.parallel_accesses", !3, !4}} ; metadata for the outer loop
    !3 = distinct !{} ; access group for instructions in the inner loop (which are implicitly contained in outer loop as well)

 
 Examples:
 
 .. code-block:: llvm
 
    @unknownPtr = external global i8
    ...
    %ptr = alloca i8
-   store i8 42, i8* %ptr, !invariant.group !0
-   call void @foo(i8* %ptr)
+   store i8 42, ptr %ptr, !invariant.group !0
+   call void @foo(ptr %ptr)
 
-   %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
-   call void @foo(i8* %ptr)
+   %a = load i8, ptr %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
+   call void @foo(ptr %ptr)
 
-   %newPtr = call i8* @getPointer(i8* %ptr)
-   %c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr
+   %newPtr = call ptr @getPointer(ptr %ptr)
+   %c = load i8, ptr %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr
 
-   %unknownValue = load i8, i8* @unknownPtr
-   store i8 %unknownValue, i8* %ptr, !invariant.group !0 ; Can assume that %unknownValue == 42
+   %unknownValue = load i8, ptr @unknownPtr
+   store i8 %unknownValue, ptr %ptr, !invariant.group !0 ; Can assume that %unknownValue == 42
 
-   call void @foo(i8* %ptr)
-   %newPtr2 = call i8* @llvm.launder.invariant.group(i8* %ptr)
-   %d = load i8, i8* %newPtr2, !invariant.group !0  ; Can't step through launder.invariant.group to get value of %ptr
+   call void @foo(ptr %ptr)
+   %newPtr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr)
+   %d = load i8, ptr %newPtr2, !invariant.group !0  ; Can't step through launder.invariant.group to get value of %ptr
 
    ...
-   declare void @foo(i8*)
-   declare i8* @getPointer(i8*)
-   declare i8* @llvm.launder.invariant.group(i8*)
+   declare void @foo(ptr)
+   declare ptr @getPointer(ptr)
+   declare ptr @llvm.launder.invariant.group.p0(ptr)
 
    !0 = !{}
 
 The invariant.group metadata must be dropped when replacing one pointer by
 another based on aliasing information. This is because invariant.group is tied
 to the SSA value of the pointer operand.
 
 .. code-block:: llvm
 
-  %v = load i8, i8* %x, !invariant.group !0
+  %v = load i8, ptr %x, !invariant.group !0
   ; if %x mustalias %y then we can replace the above instruction with
-  %v = load i8, i8* %y
+  %v = load i8, ptr %y
 
 Note that this is an experimental feature, which means that its semantics might
 change in the future.
 
 '``type``' Metadata
 ^^^^^^^^^^^^^^^^^^^
 
 See :doc:`TypeMetadata`.

 
 Example:
 
 .. code-block:: text
 
     $a = comdat any
     @a = global i32 1, comdat $a
     @b = internal global i32 2, comdat $a, section "abc", !associated !0
-    !0 = !{i32* @a}
+    !0 = !{ptr @a}
 
 
 '``prof``' Metadata
 ^^^^^^^^^^^^^^^^^^^
 
 The ``prof`` metadata is used to record profile data in the IR.
 The first operand of the metadata node indicates the profile metadata
 type. There are currently 3 types:

 to any instruction. This metadata does not impact the semantics of the program
 and may only be used to provide additional insight about the program and
 transformations to users.
 
 Example:
 
 .. code-block:: text
 
-    %a.addr = alloca float*, align 8, !annotation !0
+    %a.addr = alloca ptr, align 8, !annotation !0
     !0 = !{!"auto-init"}
 
 '``func_sanitize``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The ``func_sanitize`` metadata is used to attach two values for the function
 sanitizer instrumentation. The first value is the ubsan function signature.
 The second value is the address of the proxy variable which stores the address
 of the RTTI descriptor. If :ref:`prologue <prologuedata>` and '``func_sanitize``'
 are used at the same time, :ref:`prologue <prologuedata>` is emitted before
 '``func_sanitize``' in the output.
 
 Example:
 
 .. code-block:: text
 
-    @__llvm_rtti_proxy = private unnamed_addr constant i8* bitcast ({ i8*, i8* }* @_ZTIFvvE to i8*)
+    @__llvm_rtti_proxy = private unnamed_addr constant ptr @_ZTIFvvE
     define void @_Z3funv() !func_sanitize !0 {
       return void
     }
-    !0 = !{i32 846595819, i8** @__llvm_rtti_proxy}
+    !0 = !{i32 846595819, ptr @__llvm_rtti_proxy}
 
 Module Flags Metadata
 =====================
 
 Information about the module as a whole is difficult to convey to LLVM's
 subsystems. The LLVM IR isn't sufficient to transmit this information.
 The ``llvm.module.flags`` named metadata exists in order to facilitate
 this. These flags are in the form of key / value pairs --- much like a

 assume that access with any offset is possible.
 
 Example:
 
 If we have the following function:
 
 .. code-block:: text
 
-    define i64 @foo(i64* %0, i32* %1, i8* %2, i8 %3) {
-      store i32* %1, i32** @x
-      %5 = getelementptr inbounds i8, i8* %2, i64 5
-      %6 = load i8, i8* %5
-      %7 = getelementptr inbounds i8, i8* %2, i8 %3
-      tail call void @bar(i8 %3, i8* %7)
-      %8 = load i64, i64* %0
+    define i64 @foo(ptr %0, ptr %1, ptr %2, i8 %3) {
+      store ptr %1, ptr @x
+      %5 = getelementptr inbounds i8, ptr %2, i64 5
+      %6 = load i8, ptr %5
+      %7 = getelementptr inbounds i8, ptr %2, i8 %3
+      tail call void @bar(i8 %3, ptr %7)
+      %8 = load i64, ptr %0
       ret i64 %8
     }
 
 We can expect the record like this:
 
 .. code-block:: text
 
     params: ((param: 0, offset: [0, 7]),(param: 2, offset: [5, 5], calls: ((callee: ^3, param: 1, offset: [-128, 127]))))

 have a pointer cast formed of bitcast or getelementptr. For example, a legal
 use of it is:
 
 .. code-block:: llvm
 
     @X = global i8 4
     @Y = global i32 123
 
-    @llvm.used = appending global [2 x i8*] [
-       i8* @X,
-       i8* bitcast (i32* @Y to i8*)
+    @llvm.used = appending global [2 x ptr] [
+       ptr @X,
+       ptr @Y
     ], section "llvm.metadata"
 
 If a symbol appears in the ``@llvm.used`` list, then the compiler, assembler,
 and linker are required to treat the symbol as if there is a reference to the
 symbol that it cannot see (which is why they have to be named). For example, if
 a variable has internal linkage and no references other than that from the
 ``@llvm.used`` list, it cannot be deleted. This is commonly used to represent
 references from inline asms and other things the compiler cannot "see", and

 
 .. _gv_llvmglobalctors:
 
 The '``llvm.global_ctors``' Global Variable
 -------------------------------------------
 
 .. code-block:: llvm
 
-    %0 = type { i32, void ()*, i8* }
-    @llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, void ()* @ctor, i8* @data }]
+    %0 = type { i32, ptr, ptr }
+    @llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, ptr @ctor, ptr @data }]
 
 The ``@llvm.global_ctors`` array contains a list of constructor
 functions, priorities, and an associated global or function.
 The functions referenced by this array will be called in ascending order
 of priority (i.e. lowest first) when the module is loaded. The order of
 functions with the same priority is not defined.
 
 If the third field is non-null, and points to a global variable
 or function, the initializer function will only run if the associated
 data from the current module is not discarded.
 On ELF the referenced global variable or function must be in a comdat.
 
 .. _llvmglobaldtors:
 
 The '``llvm.global_dtors``' Global Variable
 -------------------------------------------
 
 .. code-block:: llvm
 
-    %0 = type { i32, void ()*, i8* }
-    @llvm.global_dtors = appending global [1 x %0] [%0 { i32 65535, void ()* @dtor, i8* @data }]
+    %0 = type { i32, ptr, ptr }
+    @llvm.global_dtors = appending global [1 x %0] [%0 { i32 65535, ptr @dtor, ptr @data }]
 
 The ``@llvm.global_dtors`` array contains a list of destructor
 functions, priorities, and an associated global or function.
 The functions referenced by this array will be called in descending
 order of priority (i.e. highest first) when the module is unloaded. The
 order of functions with the same priority is not defined.
 
 If the third field is non-null, and points to a global variable

 '``indirectbr``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      indirectbr <somety>* <address>, [ label <dest1>, label <dest2>, ... ]
+      indirectbr ptr <address>, [ label <dest1>, label <dest2>, ... ]
 
 Overview:
 """""""""
 
 The '``indirectbr``' instruction implements an indirect branch to a
 label within the current function, whose address is specified by
 "``address``". Address must be derived from a
 :ref:`blockaddress <blockaddress>` constant.

 
 This is typically implemented with a jump through a register.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-     indirectbr i8* %Addr, [ label %bb1, label %bb2, label %bb3 ]
+     indirectbr ptr %Addr, [ label %bb1, label %bb2, label %bb3 ]
 
 .. _i_invoke:
 
 '``invoke``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 (in-flight) exception whose unwinding was interrupted with a
 :ref:`landingpad <i_landingpad>` instruction.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      resume { i8*, i32 } %exn
+      resume { ptr, i32 } %exn
 
 .. _i_catchswitch:
 
 '``catchswitch``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 :ref:`llvm.lifetime.end <int_lifeend>` for the precise semantics of
 lifetime-manipulating intrinsics.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %ptr = alloca i32                             ; yields i32*:ptr
-      %ptr = alloca i32, i32 4                      ; yields i32*:ptr
-      %ptr = alloca i32, i32 4, align 1024          ; yields i32*:ptr
-      %ptr = alloca i32, align 1024                 ; yields i32*:ptr
+      %ptr = alloca i32                             ; yields ptr
+      %ptr = alloca i32, i32 4                      ; yields ptr
+      %ptr = alloca i32, i32 4, align 1024          ; yields ptr
+      %ptr = alloca i32, align 1024                 ; yields ptr
 
 .. _i_load:
 
 '``load``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<nontemp_node>][, !invariant.load !<empty_node>][, !invariant.group !<empty_node>][, !nonnull !<empty_node>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !align !<align_node>][, !noundef !<empty_node>]
-      <result> = load atomic [volatile] <ty>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<empty_node>]
+      <result> = load [volatile] <ty>, ptr <pointer>[, align <alignment>][, !nontemporal !<nontemp_node>][, !invariant.load !<empty_node>][, !invariant.group !<empty_node>][, !nonnull !<empty_node>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !align !<align_node>][, !noundef !<empty_node>]
+      <result> = load atomic [volatile] <ty>, ptr <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<empty_node>]
       !<nontemp_node> = !{ i32 1 }
       !<empty_node> = !{}
       !<deref_bytes_node> = !{ i64 <dereferenceable_bytes> }
       !<align_node> = !{ i64 <value_alignment> }
 
 Overview:
 """""""""
 

 padding from the loaded aggregate value.
 If ``<pointer>`` is not a well-defined value, the behavior is undefined.
 
 Examples:
 """""""""
 
 .. code-block:: llvm
 
-      %ptr = alloca i32                               ; yields i32*:ptr
-      store i32 3, i32* %ptr                          ; yields void
-      %val = load i32, i32* %ptr                      ; yields i32:val = i32 3
+      %ptr = alloca i32                               ; yields ptr
+      store i32 3, ptr %ptr                           ; yields void
+      %val = load i32, ptr %ptr                       ; yields i32:val = i32 3
 
 .. _i_store:
 
 '``store``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      store [volatile] <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<nontemp_node>][, !invariant.group !<empty_node>]        ; yields void
-      store atomic [volatile] <ty> <value>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<empty_node>] ; yields void
+      store [volatile] <ty> <value>, ptr <pointer>[, align <alignment>][, !nontemporal !<nontemp_node>][, !invariant.group !<empty_node>]        ; yields void
+      store atomic [volatile] <ty> <value>, ptr <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<empty_node>] ; yields void
       !<nontemp_node> = !{ i32 1 }
       !<empty_node> = !{}
 
 Overview:
 """""""""
 
 The '``store``' instruction is used to write to memory.
 

 :ref:`undef <undefvalues>`.
 If ``<pointer>`` is not a well-defined value, the behavior is undefined.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %ptr = alloca i32                               ; yields i32*:ptr
-      store i32 3, i32* %ptr                          ; yields void
-      %val = load i32, i32* %ptr                      ; yields i32:val = i32 3
+      %ptr = alloca i32                               ; yields ptr
+      store i32 3, ptr %ptr                           ; yields void
+      %val = load i32, ptr %ptr                       ; yields i32:val = i32 3
 
 .. _i_fence:
 
 '``fence``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 '``cmpxchg``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      cmpxchg [weak] [volatile] <ty>* <pointer>, <ty> <cmp>, <ty> <new> [syncscope("<target-scope>")] <success ordering> <failure ordering>[, align <alignment>] ; yields  { ty, i1 }
+      cmpxchg [weak] [volatile] ptr <pointer>, <ty> <cmp>, <ty> <new> [syncscope("<target-scope>")] <success ordering> <failure ordering>[, align <alignment>] ; yields  { ty, i1 }
 
 Overview:
 """""""""
 
 The '``cmpxchg``' instruction is used to atomically modify memory. It
 loads a value in memory and compares it to a given value. If they are
 equal, it tries to store a new value into the memory.
 

 load with an ordering parameter determined the second ordering parameter.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
     entry:
-      %orig = load atomic i32, i32* %ptr unordered, align 4                      ; yields i32
+      %orig = load atomic i32, ptr %ptr unordered, align 4                      ; yields i32
       br label %loop
 
     loop:
       %cmp = phi i32 [ %orig, %entry ], [%value_loaded, %loop]
       %squared = mul i32 %cmp, %cmp
-      %val_success = cmpxchg i32* %ptr, i32 %cmp, i32 %squared acq_rel monotonic ; yields  { i32, i1 }
+      %val_success = cmpxchg ptr %ptr, i32 %cmp, i32 %squared acq_rel monotonic ; yields  { i32, i1 }
       %value_loaded = extractvalue { i32, i1 } %val_success, 0
       %success = extractvalue { i32, i1 } %val_success, 1
       br i1 %success, label %done, label %loop
 
     done:
       ...
 
 .. _i_atomicrmw:
 
 '``atomicrmw``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      atomicrmw [volatile] <operation> <ty>* <pointer>, <ty> <value> [syncscope("<target-scope>")] <ordering>[, align <alignment>]  ; yields ty
+      atomicrmw [volatile] <operation> ptr <pointer>, <ty> <value> [syncscope("<target-scope>")] <ordering>[, align <alignment>]  ; yields ty
 
 Overview:
 """""""""
 
 The '``atomicrmw``' instruction is used to atomically modify memory.
 
 Arguments:
 """"""""""

 -  fmax: ``*ptr = maxnum(*ptr, val)`` (match the `llvm.maxnum.*`` intrinsic)
 -  fmin: ``*ptr = minnum(*ptr, val)`` (match the `llvm.minnum.*`` intrinsic)
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %old = atomicrmw add i32* %ptr, i32 1 acquire                        ; yields i32
+      %old = atomicrmw add ptr %ptr, i32 1 acquire                        ; yields i32
 
 .. _i_getelementptr:
 
 '``getelementptr``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = getelementptr <ty>, <ty>* <ptrval>{, [inrange] <ty> <idx>}*
-      <result> = getelementptr inbounds <ty>, <ty>* <ptrval>{, [inrange] <ty> <idx>}*
-      <result> = getelementptr <ty>, <ptr vector> <ptrval>, [inrange] <vector index type> <idx>
+      <result> = getelementptr <ty>, ptr <ptrval>{, [inrange] <ty> <idx>}*
+      <result> = getelementptr inbounds ptr <ptrval>{, [inrange] <ty> <idx>}*
+      <result> = getelementptr <ty>, <N x ptr> <ptrval>, [inrange] <vector index type> <idx>
 
 Overview:
 """""""""
 
 The '``getelementptr``' instruction is used to get the address of a
 subelement of an :ref:`aggregate <t_aggregate>` data structure. It performs
 address calculation only and does not access memory. The instruction can also
 be used to calculate a vector of such addresses.

 
 The LLVM code generated by Clang is:
 
 .. code-block:: llvm
 
     %struct.RT = type { i8, [10 x [20 x i32]], i8 }
     %struct.ST = type { i32, double, %struct.RT }
 
-    define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
+    define ptr @foo(ptr %s) nounwind uwtable readnone optsize ssp {
     entry:
-      %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
-      ret i32* %arrayidx
+      %arrayidx = getelementptr inbounds %struct.ST, ptr %s, i64 1, i32 2, i32 1, i64 5, i64 13
+      ret ptr %arrayidx
     }
 
 Semantics:
 """"""""""
 
 In the example above, the first index is indexing into the
 '``%struct.ST*``' type, which is a pointer, yielding a '``%struct.ST``'
 = '``{ i32, double, %struct.RT }``' type, a structure. The second index
 indexes into the third element of the structure, yielding a
 '``%struct.RT``' = '``{ i8 , [10 x [20 x i32]], i8 }``' type, another
 structure. The third index indexes into the second element of the
 structure, yielding a '``[10 x [20 x i32]]``' type, an array. The two
 dimensions of the array are subscripted into, yielding an '``i32``'
 type. The '``getelementptr``' instruction returns a pointer to this
-element, thus computing a value of '``i32*``' type.
+element.
 
 Note that it is perfectly legal to index partially through a structure,
 returning a pointer to an inner element. Because of this, the LLVM code
 for the given testcase is equivalent to:
 
 .. code-block:: llvm
 
-    define i32* @foo(%struct.ST* %s) {
-      %t1 = getelementptr %struct.ST, %struct.ST* %s, i32 1                        ; yields %struct.ST*:%t1
-      %t2 = getelementptr %struct.ST, %struct.ST* %t1, i32 0, i32 2                ; yields %struct.RT*:%t2
-      %t3 = getelementptr %struct.RT, %struct.RT* %t2, i32 0, i32 1                ; yields [10 x [20 x i32]]*:%t3
-      %t4 = getelementptr [10 x [20 x i32]], [10 x [20 x i32]]* %t3, i32 0, i32 5  ; yields [20 x i32]*:%t4
-      %t5 = getelementptr [20 x i32], [20 x i32]* %t4, i32 0, i32 13               ; yields i32*:%t5
-      ret i32* %t5
+    define ptr @foo(ptr %s) {
+      %t1 = getelementptr %struct.ST, ptr %s, i32 1
+      %t2 = getelementptr %struct.ST, ptr %t1, i32 0, i32 2
+      %t3 = getelementptr %struct.RT, ptr %t2, i32 0, i32 1
+      %t4 = getelementptr [10 x [20 x i32]], ptr %t3, i32 0, i32 5
+      %t5 = getelementptr [20 x i32], ptr %t4, i32 0, i32 13
+      ret ptr %t5
     }
 
 If the ``inbounds`` keyword is present, the result value of the
 ``getelementptr`` is a :ref:`poison value <poisonvalues>` if one of the
 following rules is violated:
 
 *  The base pointer has an *in bounds* address of an allocated object, which
    means that it points into an allocated object, or to its end. The only

 The getelementptr instruction is often confusing. For some more insight
 into how it works, see :doc:`the getelementptr FAQ <GetElementPtr>`.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-        ; yields [12 x i8]*:aptr
-        %aptr = getelementptr {i32, [12 x i8]}, {i32, [12 x i8]}* %saptr, i64 0, i32 1
-        ; yields i8*:vptr
-        %vptr = getelementptr {i32, <2 x i8>}, {i32, <2 x i8>}* %svptr, i64 0, i32 1, i32 1
-        ; yields i8*:eptr
-        %eptr = getelementptr [12 x i8], [12 x i8]* %aptr, i64 0, i32 1
-        ; yields i32*:iptr
-        %iptr = getelementptr [10 x i32], [10 x i32]* @arr, i16 0, i16 0
+        %aptr = getelementptr {i32, [12 x i8]}, ptr %saptr, i64 0, i32 1
+        %vptr = getelementptr {i32, <2 x i8>}, ptr %svptr, i64 0, i32 1, i32 1
+        %eptr = getelementptr [12 x i8], ptr %aptr, i64 0, i32 1
+        %iptr = getelementptr [10 x i32], ptr @arr, i16 0, i16 0
 
 Vector of pointers:
 """""""""""""""""""
 
 The ``getelementptr`` returns a vector of pointers, instead of a single address,
 when one or more of its arguments is a vector. In such cases, all vector
 arguments should have the same number of elements, and every scalar argument
 will be effectively broadcast into a vector during address calculation.
 
 .. code-block:: llvm
 
      ; All arguments are vectors:
      ;   A[i] = ptrs[i] + offsets[i]*sizeof(i8)
      %A = getelementptr i8, <4 x i8*> %ptrs, <4 x i64> %offsets
 
      ; Add the same scalar offset to each pointer of a vector:
      ;   A[i] = ptrs[i] + offset*sizeof(i8)
-     %A = getelementptr i8, <4 x i8*> %ptrs, i64 %offset
+     %A = getelementptr i8, <4 x ptr> %ptrs, i64 %offset
 
      ; Add distinct offsets to the same pointer:
      ;   A[i] = ptr + offsets[i]*sizeof(i8)
-     %A = getelementptr i8, i8* %ptr, <4 x i64> %offsets
+     %A = getelementptr i8, ptr %ptr, <4 x i64> %offsets
 
-     ; In all cases described above the type of the result is <4 x i8*>
+     ; In all cases described above the type of the result is <4 x ptr>
 
 The two following instructions are equivalent:
 
 .. code-block:: llvm
 
-     getelementptr  %struct.ST, <4 x %struct.ST*> %s, <4 x i64> %ind1,
+     getelementptr  %struct.ST, <4 x ptr> %s, <4 x i64> %ind1,
        <4 x i32> <i32 2, i32 2, i32 2, i32 2>,
        <4 x i32> <i32 1, i32 1, i32 1, i32 1>,
        <4 x i32> %ind4,
        <4 x i64> <i64 13, i64 13, i64 13, i64 13>
 
-     getelementptr  %struct.ST, <4 x %struct.ST*> %s, <4 x i64> %ind1,
+     getelementptr  %struct.ST, <4 x ptr> %s, <4 x i64> %ind1,
        i32 2, i32 1, <4 x i32> %ind4, i64 13
 
 Let's look at the C code, where the vector version of ``getelementptr``
 makes sense:
 
 .. code-block:: c
 
     // Let's assume that we vectorize the following loop:
     double *A, *B; int *C;
     for (int i = 0; i < size; ++i) {
       A[i] = B[C[i]];
     }
 
 .. code-block:: llvm
 
     ; get pointers for 8 elements from array B
-    %ptrs = getelementptr double, double* %B, <8 x i32> %C
+    %ptrs = getelementptr double, ptr %B, <8 x i32> %C
     ; load 8 elements from array B into A
-    %A = call <8 x double> @llvm.masked.gather.v8f64.v8p0f64(<8 x double*> %ptrs,
+    %A = call <8 x double> @llvm.masked.gather.v8f64.v8p0f64(<8 x ptr> %ptrs,
          i32 8, <8 x i1> %mask, <8 x double> %passthru)
 
 Conversion Operations
 ---------------------
 
 The instructions in this category are the conversion instructions
 (casting) which all take a single operand and a type. They perform
 various bit conversions on the operand.

 the same size, then nothing is done (*no-op cast*) other than a type
 change.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %X = ptrtoint i32* %P to i8                         ; yields truncation on 32-bit architecture
-      %Y = ptrtoint i32* %P to i64                        ; yields zero extension on 32-bit architecture
-      %Z = ptrtoint <4 x i32*> %P to <4 x i64>; yields vector zero extension for a vector of addresses on 32-bit architecture
+      %X = ptrtoint ptr %P to i8                         ; yields truncation on 32-bit architecture
+      %Y = ptrtoint ptr %P to i64                        ; yields zero extension on 32-bit architecture
+      %Z = ptrtoint <4 x ptr> %P to <4 x i64>; yields vector zero extension for a vector of addresses on 32-bit architecture
 
 .. _i_inttoptr:
 
 '``inttoptr .. to``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 of a pointer then a zero extension is done. If they are the same size,
 nothing is done (*no-op cast*).
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %X = inttoptr i32 255 to i32*          ; yields zero extension on 64-bit architecture
-      %Y = inttoptr i32 255 to i32*          ; yields no-op on 32-bit architecture
-      %Z = inttoptr i64 0 to i32*            ; yields truncation on 32-bit architecture
-      %Z = inttoptr <4 x i32> %G to <4 x i8*>; yields truncation of vector G to four pointers
+      %X = inttoptr i32 255 to ptr           ; yields zero extension on 64-bit architecture
+      %Y = inttoptr i32 255 to ptr           ; yields no-op on 32-bit architecture
+      %Z = inttoptr i64 0 to ptr             ; yields truncation on 32-bit architecture
+      %Z = inttoptr <4 x i32> %G to <4 x ptr>; yields truncation of vector G to four pointers
 
 .. _i_bitcast:
 
 '``bitcast .. to``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 element zero ends up in the most significant bits for big-endian.
 
 Example:
 """"""""
 
 .. code-block:: text
 
       %X = bitcast i8 255 to i8          ; yields i8 :-1
-      %Y = bitcast i32* %x to i16*      ; yields i16*:%x
+      %Y = bitcast i32* %x to i16*       ; yields i16*:%x
       %Z = bitcast <2 x i32> %V to i64;  ; yields i64: %V (depends on endianess)
       %Z = bitcast <2 x i32*> %V to <2 x i64*> ; yields <2 x i64*>
 
 .. _i_addrspacecast:
 
 '``addrspacecast .. to``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

 conversion is legal then both result and operand refer to the same memory
 location.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
-      %X = addrspacecast i32* %x to i32 addrspace(1)*    ; yields i32 addrspace(1)*:%x
-      %Y = addrspacecast i32 addrspace(1)* %y to i64 addrspace(2)*    ; yields i64 addrspace(2)*:%y
-      %Z = addrspacecast <4 x i32*> %z to <4 x float addrspace(3)*>   ; yields <4 x float addrspace(3)*>:%z
+      %X = addrspacecast ptr %x to ptr addrspace(1)
+      %Y = addrspacecast ptr addrspace(1) %y to ptr addrspace(2)
+      %Z = addrspacecast <4 x ptr> %z to <4 x ptr addrspace(3)>
 
 .. _otherops:
 
 Other Operations
 ----------------
 
 The instructions in this category are the "miscellaneous" instructions,
 which defy better classification.

 as the values being compared. Otherwise, the result is an ``i1``.
 
 Example:
 """"""""
 
 .. code-block:: text
 
       <result> = icmp eq i32 4, 5          ; yields: result=false
-      <result> = icmp ne float* %X, %X     ; yields: result=false
+      <result> = icmp ne ptr %X, %X        ; yields: result=false
       <result> = icmp ult i16  4, 5        ; yields: result=true
       <result> = icmp sgt i16  4, 5        ; yields: result=false
       <result> = icmp ule i16 -4, 5        ; yields: result=false
       <result> = icmp sge i16  4, 5        ; yields: result=false
 
 .. _i_fcmp:
 
 '``fcmp``' Instruction

 return value of the function is bound to the result argument.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       %retval = call i32 @test(i32 %argc)
-      call i32 (i8*, ...)* @printf(i8* %msg, i32 12, i8 42)        ; yields i32
+      call i32 (ptr, ...) @printf(ptr %msg, i32 12, i8 42)        ; yields i32
       %X = tail call i32 @foo()                                    ; yields i32
       %Y = tail call fastcc i32 @foo()  ; yields i32
       call void %foo(i8 signext 97)
 
       %struct.A = type { i32, i8 }
       %r = call %struct.A @foo()                        ; yields { i32, i8 }
       %gr = extractvalue %struct.A %r, 0                ; yields i32
       %gr1 = extractvalue %struct.A %r, 1               ; yields i8

 
 The optional
 ``cleanup`` flag indicates that the landing pad block is a cleanup.
 
 A ``clause`` begins with the clause type --- ``catch`` or ``filter`` --- and
 contains the global variable representing the "type" that may be caught
 or filtered respectively. Unlike the ``catch`` clause, the ``filter``
 clause takes an array constant as its argument. Use
-"``[0 x i8**] undef``" for a filter which cannot throw. The
+"``[0 x ptr] undef``" for a filter which cannot throw. The
 '``landingpad``' instruction must contain *at least* one ``clause`` or
 the ``cleanup`` flag.
 
 Semantics:
 """"""""""
 
 The '``landingpad``' instruction defines the values which are set by the
 :ref:`personality function <personalityfn>` upon re-entry to the function, and
-  A basic block that is not a landing pad block may not include a
    '``landingpad``' instruction.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       ;; A landing pad which can catch an integer.
-      %res = landingpad { i8*, i32 }
-               catch i8** @_ZTIi
+      %res = landingpad { ptr, i32 }
+               catch ptr @_ZTIi
       ;; A landing pad that is a cleanup.
-      %res = landingpad { i8*, i32 }
+      %res = landingpad { ptr, i32 }
                cleanup
       ;; A landing pad which can catch an integer and can only throw a double.
-      %res = landingpad { i8*, i32 }
-               catch i8** @_ZTIi
-               filter [1 x i8**] [i8** @_ZTId]
+      %res = landingpad { ptr, i32 }
+               catch ptr @_ZTIi
+               filter [1 x ptr] [ptr @_ZTId]
 
 .. _i_catchpad:
 
 '``catchpad``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 """"""""
 
 .. code-block:: text
 
     dispatch:
       %cs = catchswitch within none [label %handler0] unwind to caller
       ;; A catch block which can catch an integer.
     handler0:
-      %tok = catchpad within %cs [i8** @_ZTIi]
+      %tok = catchpad within %cs [ptr @_ZTIi]
 
 .. _i_cleanuppad:
 
 '``cleanuppad``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

 prepared to handle these functions regardless of the type used.
 
 This example shows how the :ref:`va_arg <i_va_arg>` instruction and the
 variable argument handling intrinsic functions are used.
 
 .. code-block:: llvm
 
     ; This struct is different for every platform. For most platforms,
-    ; it is merely an i8*.
-    %struct.va_list = type { i8* }
+    ; it is merely a ptr.
+    %struct.va_list = type { ptr }
 
     ; For Unix x86_64 platforms, va_list is the following struct:
-    ; %struct.va_list = type { i32, i32, i8*, i8* }
+    ; %struct.va_list = type { i32, i32, ptr, ptr }
 
     define i32 @test(i32 %X, ...) {
       ; Initialize variable argument processing
       %ap = alloca %struct.va_list
-      %ap2 = bitcast %struct.va_list* %ap to i8*
-      call void @llvm.va_start(i8* %ap2)
+      call void @llvm.va_start(ptr %ap)
 
       ; Read a single integer argument
-      %tmp = va_arg i8* %ap2, i32
+      %tmp = va_arg ptr %ap, i32
 
       ; Demonstrate usage of llvm.va_copy and llvm.va_end
-      %aq = alloca i8*
-      %aq2 = bitcast i8** %aq to i8*
-      call void @llvm.va_copy(i8* %aq2, i8* %ap2)
-      call void @llvm.va_end(i8* %aq2)
+      %aq = alloca ptr
+      call void @llvm.va_copy(ptr %aq, ptr %ap)
+      call void @llvm.va_end(ptr %aq)
 
       ; Stop processing of arguments.
-      call void @llvm.va_end(i8* %ap2)
+      call void @llvm.va_end(ptr %ap)
       ret i32 %tmp
     }
 
-    declare void @llvm.va_start(i8*)
-    declare void @llvm.va_copy(i8*, i8*)
-    declare void @llvm.va_end(i8*)
+    declare void @llvm.va_start(ptr)
+    declare void @llvm.va_copy(ptr, ptr)
+    declare void @llvm.va_end(ptr)
 
 .. _int_va_start:
 
 '``llvm.va_start``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.va_start(i8* <arglist>)
+      declare void @llvm.va_start(ptr <arglist>)
 
 Overview:
 """""""""
 
-The '``llvm.va_start``' intrinsic initializes ``*<arglist>`` for
+The '``llvm.va_start``' intrinsic initializes ``<arglist>`` for
 subsequent use by ``va_arg``.
 
 Arguments:
 """"""""""
 
 The argument is a pointer to a ``va_list`` element to initialize.
 
 Semantics:

 '``llvm.va_end``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.va_end(i8* <arglist>)
+      declare void @llvm.va_end(ptr <arglist>)
 
 Overview:
 """""""""
 
-The '``llvm.va_end``' intrinsic destroys ``*<arglist>``, which has been
+The '``llvm.va_end``' intrinsic destroys ``<arglist>``, which has been
 initialized previously with ``llvm.va_start`` or ``llvm.va_copy``.
 
 Arguments:
 """"""""""
 
 The argument is a pointer to a ``va_list`` to destroy.
 
 Semantics:

 '``llvm.va_copy``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.va_copy(i8* <destarglist>, i8* <srcarglist>)
+      declare void @llvm.va_copy(ptr <destarglist>, ptr <srcarglist>)
 
 Overview:
 """""""""
 
 The '``llvm.va_copy``' intrinsic copies the current argument position
 from the source argument list to the destination argument list.
 
 Arguments:

 '``llvm.gcroot``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.gcroot(i8** %ptrloc, i8* %metadata)
+      declare void @llvm.gcroot(ptr %ptrloc, ptr %metadata)
 
 Overview:
 """""""""
 
 The '``llvm.gcroot``' intrinsic declares the existence of a GC root to
 the code generator, and allows some metadata to be associated with it.
 
 Arguments:

 '``llvm.gcread``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.gcread(i8* %ObjPtr, i8** %Ptr)
+      declare ptr @llvm.gcread(ptr %ObjPtr, ptr %Ptr)
 
 Overview:
 """""""""
 
 The '``llvm.gcread``' intrinsic identifies reads of references from heap
 locations, allowing garbage collector implementations that require read
 barriers.
 

 '``llvm.gcwrite``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.gcwrite(i8* %P1, i8* %Obj, i8** %P2)
+      declare void @llvm.gcwrite(ptr %P1, ptr %Obj, ptr %P2)
 
 Overview:
 """""""""
 
 The '``llvm.gcwrite``' intrinsic identifies writes of references to heap
 locations, allowing garbage collector implementations that require write
 barriers (such as generational or reference counting collectors).
 

 
 Syntax:
 """""""
 
 ::
 
       declare token
         @llvm.experimental.gc.statepoint(i64 <id>, i32 <num patch bytes>,
-                       func_type* elementtype(func_type) <target>,
+                       ptr elementtype(func_type) <target>,
                        i64 <#call args>, i64 <flags>,
                        ... (call parameters),
                        i64 0, i64 0)
 
 Overview:
 """""""""
 
 The statepoint intrinsic represents a call which is parse-able by the

 'llvm.experimental.gc.result' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare type*
+      declare type
         @llvm.experimental.gc.result(token %statepoint_token)
 
 Overview:
 """""""""
 
 ``gc.result`` extracts the result of the original call instruction
 which was replaced by the ``gc.statepoint``.  The ``gc.result``
 intrinsic is actually a family of three intrinsics due to an

 '``llvm.returnaddress``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.returnaddress(i32 <level>)
+      declare ptr @llvm.returnaddress(i32 <level>)
 
 Overview:
 """""""""
 
 The '``llvm.returnaddress``' intrinsic attempts to compute a
 target-specific value indicating the return address of the current
 function or one of its callers.
 

 '``llvm.addressofreturnaddress``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.addressofreturnaddress()
+      declare ptr @llvm.addressofreturnaddress()
 
 Overview:
 """""""""
 
 The '``llvm.addressofreturnaddress``' intrinsic returns a target-specific
 pointer to the place in the stack frame where the return address of the
 current function is stored.
 

 '``llvm.sponentry``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.sponentry()
+      declare ptr @llvm.sponentry()
 
 Overview:
 """""""""
 
 The '``llvm.sponentry``' intrinsic returns the stack pointer value at
 the entry of the current function calling this intrinsic.
 
 Semantics:
 """"""""""
 
 Note this intrinsic is only verified on AArch64 and ARM.
 
 '``llvm.frameaddress``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.frameaddress(i32 <level>)
+      declare ptr @llvm.frameaddress(i32 <level>)
 
 Overview:
 """""""""
 
 The '``llvm.frameaddress``' intrinsic attempts to return the
 target-specific frame pointer value for the specified stack frame.
 
 Arguments:

 '``llvm.swift.async.context.addr``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8** @llvm.swift.async.context.addr()
+      declare ptr @llvm.swift.async.context.addr()
 
 Overview:
 """""""""
 
 The '``llvm.swift.async.context.addr``' intrinsic returns a pointer to
 the part of the extended frame record containing the asynchronous
 context of a Swift execution.
 
 Semantics:
 """"""""""
 
 If the caller has a ``swiftasync`` parameter, that argument will initially
 be stored at the returned address. If not, it will be initialized to null.
 
 '``llvm.localescape``' and '``llvm.localrecover``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare void @llvm.localescape(...)
-      declare i8* @llvm.localrecover(i8* %func, i8* %fp, i32 %idx)
+      declare ptr @llvm.localrecover(ptr %func, ptr %fp, i32 %idx)
 
 Overview:
 """""""""
 
 The '``llvm.localescape``' intrinsic escapes offsets of a collection of static
 allocas, and the '``llvm.localrecover``' intrinsic applies those offsets to a
 live frame pointer to recover the address of the allocation. The offset is
 computed during frame layout of the caller of ``llvm.localescape``.

 '``llvm.stacksave``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.stacksave()
+      declare ptr @llvm.stacksave()
 
 Overview:
 """""""""
 
 The '``llvm.stacksave``' intrinsic is used to remember the current state
 of the function stack, for use with
 :ref:`llvm.stackrestore <int_stackrestore>`. This is useful for
 implementing language features like scoped automatic variable sized

 '``llvm.stackrestore``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.stackrestore(i8* %ptr)
+      declare void @llvm.stackrestore(ptr %ptr)
 
 Overview:
 """""""""
 
 The '``llvm.stackrestore``' intrinsic is used to restore the state of
 the function stack to the state it was in when the corresponding
 :ref:`llvm.stacksave <int_stacksave>` intrinsic executed. This is
 useful for implementing language features like scoped automatic variable

 '``llvm.prefetch``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.prefetch(i8* <address>, i32 <rw>, i32 <locality>, i32 <cache type>)
+      declare void @llvm.prefetch(ptr <address>, i32 <rw>, i32 <locality>, i32 <cache type>)
 
 Overview:
 """""""""
 
 The '``llvm.prefetch``' intrinsic is a hint to the code generator to
 insert a prefetch instruction if supported; otherwise, it is a noop.
 Prefetches have no effect on the behavior of the program but can change
 its performance characteristics.

 '``llvm.clear_cache``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.clear_cache(i8*, i8*)
+      declare void @llvm.clear_cache(ptr, ptr)
 
 Overview:
 """""""""
 
 The '``llvm.clear_cache``' intrinsic ensures visibility of modifications
 in the specified range to the execution unit of the processor. On
 targets with non-unified instruction and data cache, the implementation
 flushes the instruction cache.

 '``llvm.instrprof.increment``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.instrprof.increment(i8* <name>, i64 <hash>,
+      declare void @llvm.instrprof.increment(ptr <name>, i64 <hash>,
                                              i32 <num-counters>, i32 <index>)
 
 Overview:
 """""""""
 
 The '``llvm.instrprof.increment``' intrinsic can be emitted by a
 frontend for use with instrumentation based profiling. These will be
 lowered by the ``-instrprof`` pass to generate execution counts of a

 '``llvm.instrprof.increment.step``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.instrprof.increment.step(i8* <name>, i64 <hash>,
+      declare void @llvm.instrprof.increment.step(ptr <name>, i64 <hash>,
                                                   i32 <num-counters>,
                                                   i32 <index>, i64 <step>)
 
 Overview:
 """""""""
 
 The '``llvm.instrprof.increment.step``' intrinsic is an extension to
 the '``llvm.instrprof.increment``' intrinsic with an additional fifth

 '``llvm.instrprof.cover``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.instrprof.cover(i8* <name>, i64 <hash>,
+      declare void @llvm.instrprof.cover(ptr <name>, i64 <hash>,
                                          i32 <num-counters>, i32 <index>)
 
 Overview:
 """""""""
 
 The '``llvm.instrprof.cover``' intrinsic is used to implement coverage
 instrumentation.
 

 '``llvm.instrprof.value.profile``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.instrprof.value.profile(i8* <name>, i64 <hash>,
+      declare void @llvm.instrprof.value.profile(ptr <name>, i64 <hash>,
                                                  i64 <value>, i32 <value_kind>,
                                                  i32 <index>)
 
 Overview:
 """""""""
 
 The '``llvm.instrprof.value.profile``' intrinsic can be emitted by a
 frontend for use with instrumentation based profiling. This will be

 '``llvm.thread.pointer``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.thread.pointer()
+      declare ptr @llvm.thread.pointer()
 
 Overview:
 """""""""
 
 The '``llvm.thread.pointer``' intrinsic returns the value of the thread
 pointer.
 
 Semantics:

 '``llvm.call.preallocated.arg``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.call.preallocated.arg(token %setup_token, i32 %arg_index)
+      declare ptr @llvm.call.preallocated.arg(token %setup_token, i32 %arg_index)
 
 Overview:
 """""""""
 
 The '``llvm.call.preallocated.arg``' intrinsic returns a pointer to the
 corresponding preallocated argument for the preallocated call.
 
 Semantics:

 '``llvm.call.preallocated.teardown``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.call.preallocated.teardown(token %setup_token)
+      declare ptr @llvm.call.preallocated.teardown(token %setup_token)
 
 Overview:
 """""""""
 
 The '``llvm.call.preallocated.teardown``' intrinsic cleans up the stack
 created by a '``llvm.call.preallocated.setup``'.
 
 Semantics:

 nested.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
         %cs = call token @llvm.call.preallocated.setup(i32 1)
-        %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
-        %y = bitcast i8* %x to i32*
-        invoke void @constructor(i32* %y) to label %conta unwind label %contb
+        %x = call ptr @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+        invoke void @constructor(ptr %x) to label %conta unwind label %contb
     conta:
-        call void @foo1(i32* preallocated(i32) %y) ["preallocated"(token %cs)]
+        call void @foo1(ptr preallocated(i32) %x) ["preallocated"(token %cs)]
         ret void
     contb:
         %s = catchswitch within none [label %catch] unwind to caller
     catch:
         %p = catchpad within %s []
         call void @llvm.call.preallocated.teardown(token %cs)
         ret void
 

 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.memcpy`` on any
 integer bit width and for different address spaces. Not all targets
 support all bit widths however.
 
 ::
 
-      declare void @llvm.memcpy.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
-                                              i32 <len>, i1 <isvolatile>)
-      declare void @llvm.memcpy.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
-                                              i64 <len>, i1 <isvolatile>)
+      declare void @llvm.memcpy.p0.p0.i32(ptr <dest>, ptr <src>,
+      declare void @llvm.memcpy.p0.p0.i64(ptr <dest>, ptr <src>,
 
 Overview:
 """""""""
 
 The '``llvm.memcpy.*``' intrinsics copy a block of memory from the
 source location to the destination location.
 
 Note that, unlike the standard libc function, the ``llvm.memcpy.*``

 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.memcpy.inline`` on any
 integer bit width and for different address spaces. Not all targets
 support all bit widths however.
 
 ::
 
-      declare void @llvm.memcpy.inline.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
-                                                     i32 <len>, i1 <isvolatile>)
-      declare void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
-                                                     i64 <len>, i1 <isvolatile>)
+      declare void @llvm.memcpy.inline.p0.p0.i32(ptr <dest>, ptr <src>,
+      declare void @llvm.memcpy.inline.p0.p0.i64(ptr <dest>, ptr <src>,
 
 Overview:
 """""""""
 
 The '``llvm.memcpy.inline.*``' intrinsics copy a block of memory from the
 source location to the destination location and guarantees that no external
 functions are called.
 

 """""""
 
 This is an overloaded intrinsic. You can use llvm.memmove on any integer
 bit width and for different address space. Not all targets support all
 bit widths however.
 
 ::
 
-      declare void @llvm.memmove.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
-                                               i32 <len>, i1 <isvolatile>)
-      declare void @llvm.memmove.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
-                                               i64 <len>, i1 <isvolatile>)
+      declare void @llvm.memmove.p0.p0.i32(ptr <dest>, ptr <src>,
+      declare void @llvm.memmove.p0.p0.i64(ptr <dest>, ptr <src>,
 
 Overview:
 """""""""
 
 The '``llvm.memmove.*``' intrinsics move a block of memory from the
 source location to the destination location. It is similar to the
 '``llvm.memcpy``' intrinsic but allows the two memory locations to
 overlap.

 """""""
 
 This is an overloaded intrinsic. You can use llvm.memset on any integer
 bit width and for different address spaces. However, not all targets
 support all bit widths.
 
 ::
 
-      declare void @llvm.memset.p0i8.i32(i8* <dest>, i8 <val>,
-                                         i32 <len>, i1 <isvolatile>)
-      declare void @llvm.memset.p0i8.i64(i8* <dest>, i8 <val>,
-                                         i64 <len>, i1 <isvolatile>)
+      declare void @llvm.memset.p0.i32(ptr <dest>, i8 <val>,
+      declare void @llvm.memset.p0.i64(ptr <dest>, i8 <val>,
 
 Overview:
 """""""""
 
 The '``llvm.memset.*``' intrinsics fill a block of memory with a
 particular byte value.
 
 Note that, unlike the standard libc function, the ``llvm.memset``

 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.memset.inline`` on any
 integer bit width and for different address spaces. Not all targets
 support all bit widths however.
 
 ::
 
-      declare void @llvm.memset.inline.p0i8.p0i8.i32(i8* <dest>, i8 <val>,
-                                                     i32 <len>,
-                                                     i1 <isvolatile>)
-      declare void @llvm.memset.inline.p0i8.p0i8.i64(i8* <dest>, i8 <val>,
-                                                     i64 <len>,
-                                                     i1 <isvolatile>)
+      declare void @llvm.memset.inline.p0.p0i8.i32(ptr <dest>, i8 <val>,
+                                                   i32 <len>, i1 <isvolatile>)
+      declare void @llvm.memset.inline.p0.p0.i64(ptr <dest>, i8 <val>,
+                                                 i64 <len>, i1 <isvolatile>)
 
 Overview:
 """""""""
 
 The '``llvm.memset.inline.*``' intrinsics fill a block of memory with a
 particular byte value and guarantees that no external functions are called.
 
 Note that, unlike the standard libc function, the ``llvm.memset.inline.*``

 precision floating-point format. The input half-float value is
 represented by an ``i16`` value.
 
 Examples:
 """""""""
 
 .. code-block:: llvm
 
-      %a = load i16, i16* @x, align 2
+      %a = load i16, ptr @x, align 2
       %res = call float @llvm.convert.from.fp16(i16 %a)
 
 Saturating floating-point to integer conversions
 ------------------------------------------------
 
 The ``fptoui`` and ``fptosi`` instructions return a
 :ref:`poison value <poisonvalues>` if the rounded-towards-zero value is not
 representable by the result type. These intrinsics provide an alternative

 the :ref:`nest <nest>` attribute, from a function. The result is a
 callable function pointer lacking the nest parameter - the caller does
 not need to provide a value for it. Instead, the value to use is stored
 in advance in a "trampoline", a block of memory usually allocated on the
 stack, which also contains code to splice the nest value into the
 argument list. This is used to implement the GCC nested function address
 extension.
 
-For example, if the function is ``i32 f(i8* nest %c, i32 %x, i32 %y)``
-then the resulting function pointer has signature ``i32 (i32, i32)*``.
+For example, if the function is ``i32 f(ptr nest %c, i32 %x, i32 %y)``
+then the resulting function pointer has signature ``i32 (i32, i32)``.
 It can be created as follows:
 
 .. code-block:: llvm
 
       %tramp = alloca [10 x i8], align 4 ; size and alignment only correct for X86
-      %tramp1 = getelementptr [10 x i8], [10 x i8]* %tramp, i32 0, i32 0
-      call i8* @llvm.init.trampoline(i8* %tramp1, i8* bitcast (i32 (i8*, i32, i32)* @f to i8*), i8* %nval)
-      %p = call i8* @llvm.adjust.trampoline(i8* %tramp1)
-      %fp = bitcast i8* %p to i32 (i32, i32)*
+      call ptr @llvm.init.trampoline(ptr %tramp, ptr @f, ptr %nval)
+      %fp = call ptr @llvm.adjust.trampoline(ptr %tramp)
 
 The call ``%val = call i32 %fp(i32 %x, i32 %y)`` is then equivalent to
-``%val = call i32 %f(i8* %nval, i32 %x, i32 %y)``.
+``%val = call i32 %f(ptr %nval, i32 %x, i32 %y)``.
 
 .. _int_it:
 
 '``llvm.init.trampoline``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.init.trampoline(i8* <tramp>, i8* <func>, i8* <nval>)
+      declare void @llvm.init.trampoline(ptr <tramp>, ptr <func>, ptr <nval>)
 
 Overview:
 """""""""
 
 This fills the memory pointed to by ``tramp`` with executable code,
 turning it into a trampoline.
 
 Arguments:
 """"""""""
 
 The ``llvm.init.trampoline`` intrinsic takes three arguments, all
 pointers. The ``tramp`` argument must point to a sufficiently large and
 sufficiently aligned block of memory; this memory is written to by the
 intrinsic. Note that the size and the alignment are target-specific -
 LLVM currently provides no portable way of determining them, so a
 front-end that generates this intrinsic needs to have some
-target-specific knowledge. The ``func`` argument must hold a function
-bitcast to an ``i8*``.
+target-specific knowledge. The ``func`` argument must hold a function.
 
 Semantics:
 """"""""""
 
 The block of memory pointed to by ``tramp`` is filled with target
 dependent code, turning it into a function. Then ``tramp`` needs to be
 passed to :ref:`llvm.adjust.trampoline <int_at>` to get a pointer which can
 be :ref:`bitcast (to a new function) and called <int_trampoline>`. The new

 '``llvm.adjust.trampoline``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.adjust.trampoline(i8* <tramp>)
+      declare ptr @llvm.adjust.trampoline(ptr <tramp>)
 
 Overview:
 """""""""
 
 This performs any required machine-specific adjustment to the address of
 a trampoline (passed as ``tramp``).
 
 Arguments:

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-    declare <4 x float> @llvm.vp.load.v4f32.p0v4f32(<4 x float>* %ptr, <4 x i1> %mask, i32 %evl)
-    declare <vscale x 2 x i16> @llvm.vp.load.nxv2i16.p0nxv2i16(<vscale x 2 x i16>* %ptr, <vscale x 2 x i1> %mask, i32 %evl)
-    declare <8 x float> @llvm.vp.load.v8f32.p1v8f32(<8 x float> addrspace(1)* %ptr, <8 x i1> %mask, i32 %evl)
-    declare <vscale x 1 x i64> @llvm.vp.load.nxv1i64.p6nxv1i64(<vscale x 1 x i64> addrspace(6)* %ptr, <vscale x 1 x i1> %mask, i32 %evl)
+    declare <4 x float> @llvm.vp.load.v4f32.p0(ptr %ptr, <4 x i1> %mask, i32 %evl)
+    declare <vscale x 2 x i16> @llvm.vp.load.nxv2i16.p0(ptr %ptr, <vscale x 2 x i1> %mask, i32 %evl)
+    declare <8 x float> @llvm.vp.load.v8f32.p1(ptr addrspace(1) %ptr, <8 x i1> %mask, i32 %evl)
+    declare <vscale x 1 x i64> @llvm.vp.load.nxv1i64.p6(ptr addrspace(6) %ptr, <vscale x 1 x i1> %mask, i32 %evl)
 
 Overview:
 """""""""
 
 The '``llvm.vp.load.*``' intrinsic is the vector length predicated version of
 the :ref:`llvm.masked.load <int_mload>` intrinsic.
 
 Arguments:

 provided. The default alignment is taken as the ABI alignment of the return
 type as specified by the :ref:`datalayout string<langref_datalayout>`.
 
 Examples:
 """""""""
 
 .. code-block:: text
 
-     %r = call <8 x i8> @llvm.vp.load.v8i8.p0v8i8(<8 x i8>* align 2 %ptr, <8 x i1> %mask, i32 %evl)
+     %r = call <8 x i8> @llvm.vp.load.v8i8.p0(ptr align 2 %ptr, <8 x i1> %mask, i32 %evl)
      ;; For all lanes below %evl, %r is lane-wise equivalent to %also.r
 
-     %also.r = call <8 x i8> @llvm.masked.load.v8i8.p0v8i8(<8 x i8>* %ptr, i32 2, <8 x i1> %mask, <8 x i8> undef)
+     %also.r = call <8 x i8> @llvm.masked.load.v8i8.p0(ptr %ptr, i32 2, <8 x i1> %mask, <8 x i8> undef)
 
 
 .. _int_vp_store:
 
 '``llvm.vp.store``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-    declare void @llvm.vp.store.v4f32.p0v4f32(<4 x float> %val, <4 x float>* %ptr, <4 x i1> %mask, i32 %evl)
-    declare void @llvm.vp.store.nxv2i16.p0nxv2i16(<vscale x 2 x i16> %val, <vscale x 2 x i16>* %ptr, <vscale x 2 x i1> %mask, i32 %evl)
-    declare void @llvm.vp.store.v8f32.p1v8f32(<8 x float> %val, <8 x float> addrspace(1)* %ptr, <8 x i1> %mask, i32 %evl)
-    declare void @llvm.vp.store.nxv1i64.p6nxv1i64(<vscale x 1 x i64> %val, <vscale x 1 x i64> addrspace(6)* %ptr, <vscale x 1 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.store.v4f32.p0(<4 x float> %val, ptr %ptr, <4 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.store.nxv2i16.p0(<vscale x 2 x i16> %val, ptr %ptr, <vscale x 2 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.store.v8f32.p1(<8 x float> %val, ptr addrspace(1) %ptr, <8 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.store.nxv1i64.p6(<vscale x 1 x i64> %val, ptr addrspace(6) %ptr, <vscale x 1 x i1> %mask, i32 %evl)
 
 Overview:
 """""""""
 
 The '``llvm.vp.store.*``' intrinsic is the vector length predicated version of
 the :ref:`llvm.masked.store <int_mstore>` intrinsic.
 
 Arguments:

 '``value``' operand as specified by the :ref:`datalayout
 string<langref_datalayout>` is used instead.
 
 Examples:
 """""""""
 
 .. code-block:: text
 
-     call void @llvm.vp.store.v8i8.p0v8i8(<8 x i8> %val, <8 x i8>* align 4 %ptr, <8 x i1> %mask, i32 %evl)
+     call void @llvm.vp.store.v8i8.p0(<8 x i8> %val, ptr align 4 %ptr, <8 x i1> %mask, i32 %evl)
      ;; For all lanes below %evl, the call above is lane-wise equivalent to the call below.
 
-     call void @llvm.masked.store.v8i8.p0v8i8(<8 x i8> %val, <8 x i8>* %ptr, i32 4, <8 x i1> %mask)
+     call void @llvm.masked.store.v8i8.p0(<8 x i8> %val, ptr %ptr, i32 4, <8 x i1> %mask)
 
 
 .. _int_experimental_vp_strided_load:
 
 '``llvm.experimental.vp.strided.load``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-    declare <4 x float> @llvm.experimental.vp.strided.load.v4f32.i64(float* %ptr, i64 %stride, <4 x i1> %mask, i32 %evl)
-    declare <vscale x 2 x i16> @llvm.experimental.vp.strided.load.nxv2i16.i64(i16* %ptr, i64 %stride, <vscale x 2 x i1> %mask, i32 %evl)
+    declare <4 x float> @llvm.experimental.vp.strided.load.v4f32.i64(ptr %ptr, i64 %stride, <4 x i1> %mask, i32 %evl)
+    declare <vscale x 2 x i16> @llvm.experimental.vp.strided.load.nxv2i16.i64(ptr %ptr, i64 %stride, <vscale x 2 x i1> %mask, i32 %evl)
 
 Overview:
 """""""""
 
 The '``llvm.experimental.vp.strided.load``' intrinsic loads, into a vector, scalar values from
 memory locations evenly spaced apart by '``stride``' number of bytes, starting from '``ptr``'.
 
 Arguments:

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-    declare void @llvm.experimental.vp.strided.store.v4f32.i64(<4 x float> %val, float* %ptr, i64 %stride, <4 x i1> %mask, i32 %evl)
-    declare void @llvm.experimental.vp.strided.store.nxv2i16.i64(<vscale x 2 x i16> %val, i16* %ptr, i64 %stride, <vscale x 2 x i1> %mask, i32 %evl)
+    declare void @llvm.experimental.vp.strided.store.v4f32.i64(<4 x float> %val, ptr %ptr, i64 %stride, <4 x i1> %mask, i32 %evl)
+    declare void @llvm.experimental.vp.strided.store.nxv2i16.i64(<vscale x 2 x i16> %val, ptr %ptr, i64 %stride, <vscale x 2 x i1> %mask, i32 %evl)
 
 Overview:
 """""""""
 
 The '``@llvm.experimental.vp.strided.store``' intrinsic stores the elements of
 '``val``' into memory locations evenly spaced apart by '``stride``' number of
 bytes, starting from '``ptr``'.
 

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-    declare <4 x double> @llvm.vp.gather.v4f64.v4p0f64(<4 x double*> %ptrs, <4 x i1> %mask, i32 %evl)
-    declare <vscale x 2 x i8> @llvm.vp.gather.nxv2i8.nxv2p0i8(<vscale x 2 x i8*> %ptrs, <vscale x 2 x i1> %mask, i32 %evl)
-    declare <2 x float> @llvm.vp.gather.v2f32.v2p2f32(<2 x float addrspace(2)*> %ptrs, <2 x i1> %mask, i32 %evl)
-    declare <vscale x 4 x i32> @llvm.vp.gather.nxv4i32.nxv4p4i32(<vscale x 4 x i32 addrspace(4)*> %ptrs, <vscale x 4 x i1> %mask, i32 %evl)
+    declare <4 x double> @llvm.vp.gather.v4f64.v4p0(<4 x ptr> %ptrs, <4 x i1> %mask, i32 %evl)
+    declare <vscale x 2 x i8> @llvm.vp.gather.nxv2i8.nxv2p0(<vscale x 2 x ptr> %ptrs, <vscale x 2 x i1> %mask, i32 %evl)
+    declare <2 x float> @llvm.vp.gather.v2f32.v2p2(<2 x ptr addrspace(2)> %ptrs, <2 x i1> %mask, i32 %evl)
+    declare <vscale x 4 x i32> @llvm.vp.gather.nxv4i32.nxv4p4(<vscale x 4 x ptr addrspace(4)> %ptrs, <vscale x 4 x i1> %mask, i32 %evl)
 
 Overview:
 """""""""
 
 The '``llvm.vp.gather.*``' intrinsic is the vector length predicated version of
 the :ref:`llvm.masked.gather <int_mgather>` intrinsic.
 
 Arguments:

 provided. The default alignment is taken as the ABI alignment of the source
 addresses as specified by the :ref:`datalayout string<langref_datalayout>`.
 
 Examples:
 """""""""
 
 .. code-block:: text
 
-     %r = call <8 x i8> @llvm.vp.gather.v8i8.v8p0i8(<8 x i8*>  align 8 %ptrs, <8 x i1> %mask, i32 %evl)
+     %r = call <8 x i8> @llvm.vp.gather.v8i8.v8p0(<8 x ptr>  align 8 %ptrs, <8 x i1> %mask, i32 %evl)
      ;; For all lanes below %evl, %r is lane-wise equivalent to %also.r
 
-     %also.r = call <8 x i8> @llvm.masked.gather.v8i8.v8p0i8(<8 x i8*> %ptrs, i32 8, <8 x i1> %mask, <8 x i8> undef)
+     %also.r = call <8 x i8> @llvm.masked.gather.v8i8.v8p0(<8 x ptr> %ptrs, i32 8, <8 x i1> %mask, <8 x i8> undef)
 
 
 .. _int_vp_scatter:
 
 '``llvm.vp.scatter``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-    declare void @llvm.vp.scatter.v4f64.v4p0f64(<4 x double> %val, <4 x double*> %ptrs, <4 x i1> %mask, i32 %evl)
-    declare void @llvm.vp.scatter.nxv2i8.nxv2p0i8(<vscale x 2 x i8> %val, <vscale x 2 x i8*> %ptrs, <vscale x 2 x i1> %mask, i32 %evl)
-    declare void @llvm.vp.scatter.v2f32.v2p2f32(<2 x float> %val, <2 x float addrspace(2)*> %ptrs, <2 x i1> %mask, i32 %evl)
-    declare void @llvm.vp.scatter.nxv4i32.nxv4p4i32(<vscale x 4 x i32> %val, <vscale x 4 x i32 addrspace(4)*> %ptrs, <vscale x 4 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.scatter.v4f64.v4p0(<4 x double> %val, <4 x ptr> %ptrs, <4 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.scatter.nxv2i8.nxv2p0(<vscale x 2 x i8> %val, <vscale x 2 x ptr> %ptrs, <vscale x 2 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.scatter.v2f32.v2p2(<2 x float> %val, <2 x ptr addrspace(2)> %ptrs, <2 x i1> %mask, i32 %evl)
+    declare void @llvm.vp.scatter.nxv4i32.nxv4p4(<vscale x 4 x i32> %val, <vscale x 4 x ptr addrspace(4)> %ptrs, <vscale x 4 x i1> %mask, i32 %evl)
 
 Overview:
 """""""""
 
 The '``llvm.vp.scatter.*``' intrinsic is the vector length predicated version of
 the :ref:`llvm.masked.scatter <int_mscatter>` intrinsic.
 
 Arguments:

 destination addresses as specified by the :ref:`datalayout
 string<langref_datalayout>`.
 
 Examples:
 """""""""
 
 .. code-block:: text
 
-     call void @llvm.vp.scatter.v8i8.v8p0i8(<8 x i8> %val, <8 x i8*> align 1 %ptrs, <8 x i1> %mask, i32 %evl)
+     call void @llvm.vp.scatter.v8i8.v8p0(<8 x i8> %val, <8 x ptr> align 1 %ptrs, <8 x i1> %mask, i32 %evl)
      ;; For all lanes below %evl, the call above is lane-wise equivalent to the call below.
 
-     call void @llvm.masked.scatter.v8i8.v8p0i8(<8 x i8> %val, <8 x i8*> %ptrs, i32 1, <8 x i1> %mask)
+     call void @llvm.masked.scatter.v8i8.v8p0(<8 x i8> %val, <8 x ptr> %ptrs, i32 1, <8 x i1> %mask)
 
 
 .. _int_vp_trunc:
 
 '``llvm.vp.trunc.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-      declare <16 x i8>  @llvm.vp.ptrtoint.v16i8.v16p0i32 (<16 x i32*> <op>, <16 x i1> <mask>, i32 <vector_length>)
-      declare <vscale x 4 x i8>  @llvm.vp.ptrtoint.nxv4i8.nxv4p0i32 (<vscale x 4 x i32*> <op>, <vscale x 4 x i1> <mask>, i32 <vector_length>)
-      declare <256 x i64>  @llvm.vp.ptrtoint.v16i64.v16p0i32 (<256 x i32*> <op>, <256 x i1> <mask>, i32 <vector_length>)
+      declare <16 x i8>  @llvm.vp.ptrtoint.v16i8.v16p0(<16 x ptr> <op>, <16 x i1> <mask>, i32 <vector_length>)
+      declare <vscale x 4 x i8>  @llvm.vp.ptrtoint.nxv4i8.nxv4p0(<vscale x 4 x ptr> <op>, <vscale x 4 x i1> <mask>, i32 <vector_length>)
+      declare <256 x i64>  @llvm.vp.ptrtoint.v16i64.v16p0(<256 x ptr> <op>, <256 x i1> <mask>, i32 <vector_length>)
 
 Overview:
 """""""""
 
 The '``llvm.vp.ptrtoint``' intrinsic converts its pointer to the integer return
 type.  The operation has a mask and an explicit vector length parameter.
 
 

 The conversion is performed on lane positions below the explicit vector length
 and where the vector mask is true.  Masked-off lanes are undefined.
 
 Examples:
 """""""""
 
 .. code-block:: llvm
 
-      %r = call <4 x i8> @llvm.vp.ptrtoint.v4i8.v4p0i32(<4 x i32*> %a, <4 x i1> %mask, i32 %evl)
+      %r = call <4 x i8> @llvm.vp.ptrtoint.v4i8.v4p0i32(<4 x ptr> %a, <4 x i1> %mask, i32 %evl)
       ;; For all lanes below %evl, %r is lane-wise equivalent to %also.r
 
-      %t = ptrtoint <4 x i32*> %a to <4 x i8>
+      %t = ptrtoint <4 x ptr> %a to <4 x i8>
       %also.r = select <4 x i1> %mask, <4 x i8> %t, <4 x i8> undef
 
 
 .. _int_vp_inttoptr:
 
 '``llvm.vp.inttoptr.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic.
 
 ::
 
-      declare <16 x i32*>  @llvm.vp.inttoptr.v16p0i32.v16i32 (<16 x i32> <op>, <16 x i1> <mask>, i32 <vector_length>)
-      declare <vscale x 4 x i32*>  @llvm.vp.inttoptr.nxv4p0i32.nxv4i32 (<vscale x 4 x i32> <op>, <vscale x 4 x i1> <mask>, i32 <vector_length>)
-      declare <256 x i32*>  @llvm.vp.inttoptr.v256p0i32.v256i32 (<256 x i32> <op>, <256 x i1> <mask>, i32 <vector_length>)
+      declare <16 x ptr>  @llvm.vp.inttoptr.v16p0.v16i32 (<16 x i32> <op>, <16 x i1> <mask>, i32 <vector_length>)
+      declare <vscale x 4 x ptr>  @llvm.vp.inttoptr.nxv4p0.nxv4i32 (<vscale x 4 x i32> <op>, <vscale x 4 x i1> <mask>, i32 <vector_length>)
+      declare <256 x ptr>  @llvm.vp.inttoptr.v256p0.v256i32 (<256 x i32> <op>, <256 x i1> <mask>, i32 <vector_length>)
 
 Overview:
 """""""""
 
 The '``llvm.vp.inttoptr``' intrinsic converts its integer value to the point
 return type. The operation has a mask and an explicit vector length parameter.
 
 

 The conversion is performed on lane positions below the explicit vector length
 and where the vector mask is true.  Masked-off lanes are undefined.
 
 Examples:
 """""""""
 
 .. code-block:: llvm
 
-      %r = call <4 x i32*> @llvm.vp.inttoptr.v4p0i32.v4i32(<4 x i32> %a, <4 x i1> %mask, i32 %evl)
+      %r = call <4 x ptr> @llvm.vp.inttoptr.v4p0i32.v4i32(<4 x i32> %a, <4 x i1> %mask, i32 %evl)
       ;; For all lanes below %evl, %r is lane-wise equivalent to %also.r
 
-      %t = inttoptr <4 x i32> %a to <4 x i32*>
-      %also.r = select <4 x i1> %mask, <4 x i32*> %t, <4 x i32*> undef
+      %t = inttoptr <4 x i32> %a to <4 x ptr>
+      %also.r = select <4 x i1> %mask, <4 x ptr> %t, <4 x ptr> undef
 
 
 .. _int_vp_fcmp:
 
 '``llvm.vp.fcmp.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. The loaded data is a vector of any integer, floating-point or pointer data type.
 
 ::
 
-      declare <16 x float>  @llvm.masked.load.v16f32.p0v16f32 (<16 x float>* <ptr>, i32 <alignment>, <16 x i1> <mask>, <16 x float> <passthru>)
-      declare <2 x double>  @llvm.masked.load.v2f64.p0v2f64  (<2 x double>* <ptr>, i32 <alignment>, <2 x i1>  <mask>, <2 x double> <passthru>)
-      ;; The data is a vector of pointers to double
-      declare <8 x double*> @llvm.masked.load.v8p0f64.p0v8p0f64    (<8 x double*>* <ptr>, i32 <alignment>, <8 x i1> <mask>, <8 x double*> <passthru>)
-      ;; The data is a vector of function pointers
-      declare <8 x i32 ()*> @llvm.masked.load.v8p0f_i32f.p0v8p0f_i32f (<8 x i32 ()*>* <ptr>, i32 <alignment>, <8 x i1> <mask>, <8 x i32 ()*> <passthru>)
+      declare <16 x float>  @llvm.masked.load.v16f32.p0(ptr <ptr>, i32 <alignment>, <16 x i1> <mask>, <16 x float> <passthru>)
+      declare <2 x double>  @llvm.masked.load.v2f64.p0(ptr <ptr>, i32 <alignment>, <2 x i1>  <mask>, <2 x double> <passthru>)
+      ;; The data is a vector of pointers
+      declare <8 x ptr> @llvm.masked.load.v8p0.p0(ptr <ptr>, i32 <alignment>, <8 x i1> <mask>, <8 x ptr> <passthru>)
 
 Overview:
 """""""""
 
 Reads a vector from memory according to the provided mask. The mask holds a bit for each vector lane, and is used to prevent memory accesses to the masked-off lanes. The masked-off lanes in the result vector are taken from the corresponding lanes of the '``passthru``' operand.
 
 
 Arguments:
 """"""""""
 
 The first operand is the base pointer for the load. The second operand is the alignment of the source location. It must be a power of two constant integer value. The third operand, mask, is a vector of boolean values with the same number of elements as the return type. The fourth is a pass-through value that is used to fill the masked-off lanes of the result. The return type, underlying type of the base pointer and the type of the '``passthru``' operand are the same vector types.
 
 Semantics:
 """"""""""
 
 The '``llvm.masked.load``' intrinsic is designed for conditional reading of selected vector elements in a single IR operation. It is useful for targets that support vector masked loads and allows vectorizing predicated basic blocks on these targets. Other targets may support this intrinsic differently, for example by lowering it into a sequence of branches that guard scalar load operations.
 The result of this operation is equivalent to a regular vector load instruction followed by a 'select' between the loaded and the passthru values, predicated on the same mask. However, using this intrinsic prevents exceptions on memory access to masked-off lanes.
 
 
 ::
 
-       %res = call <16 x float> @llvm.masked.load.v16f32.p0v16f32 (<16 x float>* %ptr, i32 4, <16 x i1>%mask, <16 x float> %passthru)
+       %res = call <16 x float> @llvm.masked.load.v16f32.p0(ptr %ptr, i32 4, <16 x i1>%mask, <16 x float> %passthru)
 
        ;; The result of the two following instructions is identical aside from potential memory access exception
-       %loadlal = load <16 x float>, <16 x float>* %ptr, align 4
+       %loadlal = load <16 x float>, ptr %ptr, align 4
        %res = select <16 x i1> %mask, <16 x float> %loadlal, <16 x float> %passthru
 
 .. _int_mstore:
 
 '``llvm.masked.store.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. The data stored in memory is a vector of any integer, floating-point or pointer data type.
 
 ::
 
-       declare void @llvm.masked.store.v8i32.p0v8i32  (<8  x i32>   <value>, <8  x i32>*   <ptr>, i32 <alignment>,  <8  x i1> <mask>)
-       declare void @llvm.masked.store.v16f32.p0v16f32 (<16 x float> <value>, <16 x float>* <ptr>, i32 <alignment>,  <16 x i1> <mask>)
-       ;; The data is a vector of pointers to double
-       declare void @llvm.masked.store.v8p0f64.p0v8p0f64    (<8 x double*> <value>, <8 x double*>* <ptr>, i32 <alignment>, <8 x i1> <mask>)
-       ;; The data is a vector of function pointers
-       declare void @llvm.masked.store.v4p0f_i32f.p0v4p0f_i32f (<4 x i32 ()*> <value>, <4 x i32 ()*>* <ptr>, i32 <alignment>, <4 x i1> <mask>)
+       declare void @llvm.masked.store.v8i32.p0 (<8  x i32>   <value>, ptr <ptr>, i32 <alignment>, <8  x i1> <mask>)
+       declare void @llvm.masked.store.v16f32.p0(<16 x float> <value>, ptr <ptr>, i32 <alignment>, <16 x i1> <mask>)
+       ;; The data is a vector of pointers
+       declare void @llvm.masked.store.v8p0.p0  (<8 x ptr>    <value>, ptr <ptr>, i32 <alignment>, <8 x i1> <mask>)
 
 Overview:
 """""""""
 
 Writes a vector to memory according to the provided mask. The mask holds a bit for each vector lane, and is used to prevent memory accesses to the masked-off lanes.
 
 Arguments:
 """"""""""
 
 The first operand is the vector value to be written to memory. The second operand is the base pointer for the store, it has the same underlying type as the value operand. The third operand is the alignment of the destination location. It must be a power of two constant integer value. The fourth operand, mask, is a vector of boolean values. The types of the mask and the value operand must have the same number of vector elements.
 
 
 Semantics:
 """"""""""
 
 The '``llvm.masked.store``' intrinsics is designed for conditional writing of selected vector elements in a single IR operation. It is useful for targets that support vector masked store and allows vectorizing predicated basic blocks on these targets. Other targets may support this intrinsic differently, for example by lowering it into a sequence of branches that guard scalar store operations.
 The result of this operation is equivalent to a load-modify-store sequence. However, using this intrinsic prevents exceptions and data races on memory access to masked-off lanes.
 
 ::
 
-       call void @llvm.masked.store.v16f32.p0v16f32(<16 x float> %value, <16 x float>* %ptr, i32 4,  <16 x i1> %mask)
+       call void @llvm.masked.store.v16f32.p0(<16 x float> %value, ptr %ptr, i32 4,  <16 x i1> %mask)
 
        ;; The result of the following instructions is identical aside from potential data races and memory access exceptions
-       %oldval = load <16 x float>, <16 x float>* %ptr, align 4
+       %oldval = load <16 x float>, ptr %ptr, align 4
        %res = select <16 x i1> %mask, <16 x float> %value, <16 x float> %oldval
-       store <16 x float> %res, <16 x float>* %ptr, align 4
+       store <16 x float> %res, ptr %ptr, align 4
 
 
 Masked Vector Gather and Scatter Intrinsics
 -------------------------------------------
 
 LLVM provides intrinsics for vector gather and scatter operations. They are similar to :ref:`Masked Vector Load and Store <int_mload_mstore>`, except they are designed for arbitrary memory accesses, rather than sequential memory accesses. Gather and scatter also employ a mask operand, which holds one bit per vector element, switching the associated vector lane on or off. The memory addresses corresponding to the "off" lanes are not accessed. When all bits are off, no memory is accessed.
 
 .. _int_mgather:
 
 '``llvm.masked.gather.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. The loaded data are multiple scalar values of any integer, floating-point or pointer data type gathered together into one vector.
 
 ::
 
-      declare <16 x float> @llvm.masked.gather.v16f32.v16p0f32   (<16 x float*> <ptrs>, i32 <alignment>, <16 x i1> <mask>, <16 x float> <passthru>)
-      declare <2 x double> @llvm.masked.gather.v2f64.v2p1f64     (<2 x double addrspace(1)*> <ptrs>, i32 <alignment>, <2 x i1>  <mask>, <2 x double> <passthru>)
-      declare <8 x float*> @llvm.masked.gather.v8p0f32.v8p0p0f32 (<8 x float**> <ptrs>, i32 <alignment>, <8 x i1>  <mask>, <8 x float*> <passthru>)
+      declare <16 x float> @llvm.masked.gather.v16f32.v16p0(<16 x ptr> <ptrs>, i32 <alignment>, <16 x i1> <mask>, <16 x float> <passthru>)
+      declare <2 x double> @llvm.masked.gather.v2f64.v2p1(<2 x ptr addrspace(1)> <ptrs>, i32 <alignment>, <2 x i1>  <mask>, <2 x double> <passthru>)
+      declare <8 x ptr> @llvm.masked.gather.v8p0.v8p0(<8 x ptr> <ptrs>, i32 <alignment>, <8 x i1>  <mask>, <8 x ptr> <passthru>)
 
 Overview:
 """""""""
 
 Reads scalar values from arbitrary memory locations and gathers them into one vector. The memory locations are provided in the vector of pointers '``ptrs``'. The memory is accessed according to the provided mask. The mask holds a bit for each vector lane, and is used to prevent memory accesses to the masked-off lanes. The masked-off lanes in the result vector are taken from the corresponding lanes of the '``passthru``' operand.
 
 
 Arguments:
 """"""""""
 
 The first operand is a vector of pointers which holds all memory addresses to read. The second operand is an alignment of the source addresses. It must be 0 or a power of two constant integer value. The third operand, mask, is a vector of boolean values with the same number of elements as the return type. The fourth is a pass-through value that is used to fill the masked-off lanes of the result. The return type, underlying type of the vector of pointers and the type of the '``passthru``' operand are the same vector types.
 
 Semantics:
 """"""""""
 
 The '``llvm.masked.gather``' intrinsic is designed for conditional reading of multiple scalar values from arbitrary memory locations in a single IR operation. It is useful for targets that support vector masked gathers and allows vectorizing basic blocks with data and control divergence. Other targets may support this intrinsic differently, for example by lowering it into a sequence of scalar load operations.
 The semantics of this operation are equivalent to a sequence of conditional scalar loads with subsequent gathering all loaded values into a single vector. The mask restricts memory access to certain lanes and facilitates vectorization of predicated basic blocks.
 
 
 ::
 
-       %res = call <4 x double> @llvm.masked.gather.v4f64.v4p0f64 (<4 x double*> %ptrs, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x double> undef)
+       %res = call <4 x double> @llvm.masked.gather.v4f64.v4p0(<4 x ptr> %ptrs, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x double> undef)
 
        ;; The gather with all-true mask is equivalent to the following instruction sequence
-       %ptr0 = extractelement <4 x double*> %ptrs, i32 0
-       %ptr1 = extractelement <4 x double*> %ptrs, i32 1
-       %ptr2 = extractelement <4 x double*> %ptrs, i32 2
-       %ptr3 = extractelement <4 x double*> %ptrs, i32 3
-
-       %val0 = load double, double* %ptr0, align 8
-       %val1 = load double, double* %ptr1, align 8
-       %val2 = load double, double* %ptr2, align 8
-       %val3 = load double, double* %ptr3, align 8
+       %ptr0 = extractelement <4 x ptr> %ptrs, i32 0
+       %ptr1 = extractelement <4 x ptr> %ptrs, i32 1
+       %ptr2 = extractelement <4 x ptr> %ptrs, i32 2
+       %ptr3 = extractelement <4 x ptr> %ptrs, i32 3
+
+       %val0 = load double, ptr %ptr0, align 8
+       %val1 = load double, ptr %ptr1, align 8
+       %val2 = load double, ptr %ptr2, align 8
+       %val3 = load double, ptr %ptr3, align 8
 
        %vec0    = insertelement <4 x double>undef, %val0, 0
        %vec01   = insertelement <4 x double>%vec0, %val1, 1
        %vec012  = insertelement <4 x double>%vec01, %val2, 2
        %vec0123 = insertelement <4 x double>%vec012, %val3, 3
 
 .. _int_mscatter:
 
 '``llvm.masked.scatter.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. The data stored in memory is a vector of any integer, floating-point or pointer data type. Each vector element is stored in an arbitrary memory address. Scatter with overlapping addresses is guaranteed to be ordered from least-significant to most-significant element.
 
 ::
 
-       declare void @llvm.masked.scatter.v8i32.v8p0i32     (<8 x i32>     <value>, <8 x i32*>     <ptrs>, i32 <alignment>, <8 x i1>  <mask>)
-       declare void @llvm.masked.scatter.v16f32.v16p1f32   (<16 x float>  <value>, <16 x float addrspace(1)*>  <ptrs>, i32 <alignment>, <16 x i1> <mask>)
-       declare void @llvm.masked.scatter.v4p0f64.v4p0p0f64 (<4 x double*> <value>, <4 x double**> <ptrs>, i32 <alignment>, <4 x i1>  <mask>)
+       declare void @llvm.masked.scatter.v8i32.v8p0  (<8 x i32>    <value>, <8 x ptr>               <ptrs>, i32 <alignment>, <8 x i1>  <mask>)
+       declare void @llvm.masked.scatter.v16f32.v16p1(<16 x float> <value>, <16 x ptr addrspace(1)> <ptrs>, i32 <alignment>, <16 x i1> <mask>)
+       declare void @llvm.masked.scatter.v4p0.v4p0   (<4 x ptr>    <value>, <4 x ptr>               <ptrs>, i32 <alignment>, <4 x i1>  <mask>)
 
 Overview:
 """""""""
 
 Writes each element from the value vector to the corresponding memory address. The memory addresses are represented as a vector of pointers. Writing is done according to the provided mask. The mask holds a bit for each vector lane, and is used to prevent memory accesses to the masked-off lanes.
 
 Arguments:
 """"""""""
 
 The first operand is a vector value to be written to memory. The second operand is a vector of pointers, pointing to where the value elements should be stored. It has the same underlying type as the value operand. The third operand is an alignment of the destination addresses. It must be 0 or a power of two constant integer value. The fourth operand, mask, is a vector of boolean values. The types of the mask and the value operand must have the same number of vector elements.
 
 Semantics:
 """"""""""
 
 The '``llvm.masked.scatter``' intrinsics is designed for writing selected vector elements to arbitrary memory addresses in a single IR operation. The operation may be conditional, when not all bits in the mask are switched on. It is useful for targets that support vector masked scatter and allows vectorizing basic blocks with data and control divergence. Other targets may support this intrinsic differently, for example by lowering it into a sequence of branches that guard scalar store operations.
 
 ::
 
        ;; This instruction unconditionally stores data vector in multiple addresses
-       call @llvm.masked.scatter.v8i32.v8p0i32 (<8 x i32> %value, <8 x i32*> %ptrs, i32 4,  <8 x i1>  <true, true, .. true>)
+       call @llvm.masked.scatter.v8i32.v8p0(<8 x i32> %value, <8 x ptr> %ptrs, i32 4,  <8 x i1>  <true, true, .. true>)
 
        ;; It is equivalent to a list of scalar stores
        %val0 = extractelement <8 x i32> %value, i32 0
        %val1 = extractelement <8 x i32> %value, i32 1
        ..
        %val7 = extractelement <8 x i32> %value, i32 7
-       %ptr0 = extractelement <8 x i32*> %ptrs, i32 0
-       %ptr1 = extractelement <8 x i32*> %ptrs, i32 1
+       %ptr0 = extractelement <8 x ptr> %ptrs, i32 0
+       %ptr1 = extractelement <8 x ptr> %ptrs, i32 1
        ..
-       %ptr7 = extractelement <8 x i32*> %ptrs, i32 7
+       %ptr7 = extractelement <8 x ptr> %ptrs, i32 7
        ;; Note: the order of the following stores is important when they overlap:
-       store i32 %val0, i32* %ptr0, align 4
-       store i32 %val1, i32* %ptr1, align 4
+       store i32 %val0, ptr %ptr0, align 4
+       store i32 %val1, ptr %ptr1, align 4
        ..
-       store i32 %val7, i32* %ptr7, align 4
+       store i32 %val7, ptr %ptr7, align 4
 
 
 Masked Vector Expanding Load and Compressing Store Intrinsics
 -------------------------------------------------------------
 
 LLVM provides intrinsics for expanding load and compressing store operations. Data selected from a vector according to a mask is stored in consecutive memory addresses (compressed store), and vice-versa (expanding load). These operations effective map to "if (cond.i) a[j++] = v.i" and "if (cond.i) v.i = a[j++]" patterns, respectively. Note that when the mask starts with '1' bits followed by '0' bits, these operations are identical to :ref:`llvm.masked.store <int_mstore>` and :ref:`llvm.masked.load <int_mload>`.
 
 .. _int_expandload:
 
 '``llvm.masked.expandload.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. Several values of integer, floating point or pointer data type are loaded from consecutive memory addresses and stored into the elements of a vector according to the mask.
 
 ::
 
-      declare <16 x float>  @llvm.masked.expandload.v16f32 (float* <ptr>, <16 x i1> <mask>, <16 x float> <passthru>)
-      declare <2 x i64>     @llvm.masked.expandload.v2i64 (i64* <ptr>, <2 x i1>  <mask>, <2 x i64> <passthru>)
+      declare <16 x float>  @llvm.masked.expandload.v16f32 (ptr <ptr>, <16 x i1> <mask>, <16 x float> <passthru>)
+      declare <2 x i64>     @llvm.masked.expandload.v2i64 (ptr <ptr>, <2 x i1>  <mask>, <2 x i64> <passthru>)
 
 Overview:
 """""""""
 
 Reads a number of scalar values sequentially from memory location provided in '``ptr``' and spreads them in a vector. The '``mask``' holds a bit for each vector lane. The number of elements read from memory is equal to the number of '1' bits in the mask. The loaded elements are positioned in the destination vector according to the sequence of '1' and '0' bits in the mask. E.g., if the mask vector is '10010001', "expandload" reads 3 values from memory addresses ptr, ptr+1, ptr+2 and places them in lanes 0, 3 and 7 accordingly. The masked-off lanes are filled by elements from the corresponding lanes of the '``passthru``' operand.
 
 
 Arguments:
for (int i = 0; i < size; ++i) {
         A[i] = B[j++];
     }
 
 
 .. code-block:: llvm
 
     ; Load several elements from array B and expand them in a vector.
     ; The number of loaded elements is equal to the number of '1' elements in the Mask.
-    %Tmp = call <8 x double> @llvm.masked.expandload.v8f64(double* %Bptr, <8 x i1> %Mask, <8 x double> undef)
+    %Tmp = call <8 x double> @llvm.masked.expandload.v8f64(ptr %Bptr, <8 x i1> %Mask, <8 x double> undef)
     ; Store the result in A
-    call void @llvm.masked.store.v8f64.p0v8f64(<8 x double> %Tmp, <8 x double>* %Aptr, i32 8, <8 x i1> %Mask)
+    call void @llvm.masked.store.v8f64.p0(<8 x double> %Tmp, ptr %Aptr, i32 8, <8 x i1> %Mask)
 
     ; %Bptr should be increased on each iteration according to the number of '1' elements in the Mask.
     %MaskI = bitcast <8 x i1> %Mask to i8
     %MaskIPopcnt = call i8 @llvm.ctpop.i8(i8 %MaskI)
     %MaskI64 = zext i8 %MaskIPopcnt to i64
     %BNextInd = add i64 %BInd, %MaskI64
 
 
 Other targets may support this intrinsic differently, for example, by lowering it into a sequence of conditional scalar load operations and shuffles.
 If all mask elements are '1', the intrinsic behavior is equivalent to the regular unmasked vector load.
 
 .. _int_compressstore:
 
 '``llvm.masked.compressstore.*``' Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. A number of scalar values of integer, floating point or pointer data type are collected from an input vector and stored into adjacent memory addresses. A mask defines which elements to collect from the vector.
 
 ::
 
-      declare void @llvm.masked.compressstore.v8i32  (<8  x i32>   <value>, i32*   <ptr>, <8  x i1> <mask>)
-      declare void @llvm.masked.compressstore.v16f32 (<16 x float> <value>, float* <ptr>, <16 x i1> <mask>)
+      declare void @llvm.masked.compressstore.v8i32  (<8  x i32>   <value>, ptr <ptr>, <8  x i1> <mask>)
+      declare void @llvm.masked.compressstore.v16f32 (<16 x float> <value>, ptr <ptr>, <16 x i1> <mask>)
 
 Overview:
 """""""""
 
 Selects elements from input vector '``value``' according to the '``mask``'. All selected elements are written into adjacent memory addresses starting at address '`ptr`', from lower to higher. The mask holds a bit for each vector lane, and is used to select elements to be stored. The number of elements to be stored is equal to the number of active bits in the mask.
 
 Arguments:
 """"""""""
for (int i = 0; i < size; ++i) {
       if (C[i] != 0)
         B[j++] = A[i]
     }
 
 
 .. code-block:: llvm
 
     ; Load elements from A.
-    %Tmp = call <8 x double> @llvm.masked.load.v8f64.p0v8f64(<8 x double>* %Aptr, i32 8, <8 x i1> %Mask, <8 x double> undef)
+    %Tmp = call <8 x double> @llvm.masked.load.v8f64.p0(ptr %Aptr, i32 8, <8 x i1> %Mask, <8 x double> undef)
     ; Store all selected elements consecutively in array B
-    call <void> @llvm.masked.compressstore.v8f64(<8 x double> %Tmp, double* %Bptr, <8 x i1> %Mask)
+    call <void> @llvm.masked.compressstore.v8f64(<8 x double> %Tmp, ptr %Bptr, <8 x i1> %Mask)
 
     ; %Bptr should be increased on each iteration according to the number of '1' elements in the Mask.
     %MaskI = bitcast <8 x i1> %Mask to i8
     %MaskIPopcnt = call i8 @llvm.ctpop.i8(i8 %MaskI)
     %MaskI64 = zext i8 %MaskIPopcnt to i64
     %BNextInd = add i64 %BInd, %MaskI64
 
 

 '``llvm.lifetime.start``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.lifetime.start(i64 <size>, i8* nocapture <ptr>)
+      declare void @llvm.lifetime.start(i64 <size>, ptr nocapture <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.lifetime.start``' intrinsic specifies the start of a memory
 object's lifetime.
 
 Arguments:

 '``llvm.lifetime.end``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.lifetime.end(i64 <size>, i8* nocapture <ptr>)
+      declare void @llvm.lifetime.end(i64 <size>, ptr nocapture <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.lifetime.end``' intrinsic specifies the end of a memory object's
 lifetime.
 
 Arguments:

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. The memory object can belong to any address space.
 
 ::
 
-      declare {}* @llvm.invariant.start.p0i8(i64 <size>, i8* nocapture <ptr>)
+      declare ptr @llvm.invariant.start.p0(i64 <size>, ptr nocapture <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.invariant.start``' intrinsic specifies that the contents of
 a memory object will not change.
 
 Arguments:

 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 This is an overloaded intrinsic. The memory object can belong to any address space.
 
 ::
 
-      declare void @llvm.invariant.end.p0i8({}* <start>, i64 <size>, i8* nocapture <ptr>)
+      declare void @llvm.invariant.end.p0(ptr <start>, i64 <size>, ptr nocapture <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.invariant.end``' intrinsic specifies that the contents of a
 memory object are mutable.
 
 Arguments:

 Syntax:
 """""""
 This is an overloaded intrinsic. The memory object can belong to any address
 space. The returned pointer must belong to the same address space as the
 argument.
 
 ::
 
-      declare i8* @llvm.launder.invariant.group.p0i8(i8* <ptr>)
+      declare ptr @llvm.launder.invariant.group.p0(ptr <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.launder.invariant.group``' intrinsic can be used when an invariant
 established by ``invariant.group`` metadata no longer holds, to obtain a new
 pointer value that carries fresh invariant group information. It is an
 experimental intrinsic, which means that its semantics might change in the

 Syntax:
 """""""
 This is an overloaded intrinsic. The memory object can belong to any address
 space. The returned pointer must belong to the same address space as the
 argument.
 
 ::
 
-      declare i8* @llvm.strip.invariant.group.p0i8(i8* <ptr>)
+      declare ptr @llvm.strip.invariant.group.p0(ptr <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.strip.invariant.group``' intrinsic can be used when an invariant
 established by ``invariant.group`` metadata no longer holds, to obtain a new pointer
 value that does not carry the invariant information. It is an experimental
 intrinsic, which means that its semantics might change in the future.

 noalias property it signifies would spill across loop iterations, whereas it
 was only valid within a single iteration.
 
 .. code-block:: llvm
 
   ; This examples shows two possible positions for noalias.decl and how they impact the semantics:
   ; If it is outside the loop (Version 1), then %a and %b are noalias across *all* iterations.
   ; If it is inside the loop (Version 2), then %a and %b are noalias only within *one* iteration.
-  declare void @decl_in_loop(i8* %a.base, i8* %b.base) {
+  declare void @decl_in_loop(ptr %a.base, ptr %b.base) {
   entry:
     ; call void @llvm.experimental.noalias.scope.decl(metadata !2) ; Version 1: noalias decl outside loop
     br label %loop
 
   loop:
-    %a = phi i8* [ %a.base, %entry ], [ %a.inc, %loop ]
-    %b = phi i8* [ %b.base, %entry ], [ %b.inc, %loop ]
+    %a = phi ptr [ %a.base, %entry ], [ %a.inc, %loop ]
+    %b = phi ptr [ %b.base, %entry ], [ %b.inc, %loop ]
     ; call void @llvm.experimental.noalias.scope.decl(metadata !2) ; Version 2: noalias decl inside loop
-    %val = load i8, i8* %a, !alias.scope !2
-    store i8 %val, i8* %b, !noalias !2
-    %a.inc = getelementptr inbounds i8, i8* %a, i64 1
-    %b.inc = getelementptr inbounds i8, i8* %b, i64 1
+    %val = load i8, ptr %a, !alias.scope !2
+    store i8 %val, ptr %b, !noalias !2
+    %a.inc = getelementptr inbounds i8, ptr %a, i64 1
+    %b.inc = getelementptr inbounds i8, ptr %b, i64 1
     %cond = call i1 @cond()
     br i1 %cond, label %loop, label %exit
 
   exit:
     ret void
   }
 
   !0 = !{!0} ; domain

 '``llvm.var.annotation``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32  <int>)
+      declare void @llvm.var.annotation(ptr <val>, ptr <str>, ptr <str>, i32  <int>)
 
 Overview:
 """""""""
 
 The '``llvm.var.annotation``' intrinsic.
 
 Arguments:
 """"""""""

 
 This is an overloaded intrinsic. You can use '``llvm.ptr.annotation``' on a
 pointer to an integer of any width. *NOTE* you must specify an address space for
 the pointer. The identifier for the default address space is the integer
 '``0``'.
 
 ::
 
-      declare i8*   @llvm.ptr.annotation.p<address space>i8(i8* <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i16*  @llvm.ptr.annotation.p<address space>i16(i16* <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i32*  @llvm.ptr.annotation.p<address space>i32(i32* <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i64*  @llvm.ptr.annotation.p<address space>i64(i64* <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i256* @llvm.ptr.annotation.p<address space>i256(i256* <val>, i8* <str>, i8* <str>, i32  <int>)
+      declare ptr @llvm.ptr.annotation.p0(ptr <val>, ptr <str>, ptr <str>, i32 <int>)
+      declare ptr @llvm.ptr.annotation.p1(ptr addrspace(1) <val>, ptr <str>, ptr <str>, i32 <int>)
 
 Overview:
 """""""""
 
 The '``llvm.ptr.annotation``' intrinsic.
 
 Arguments:
 """"""""""

 Syntax:
 """""""
 
 This is an overloaded intrinsic. You can use '``llvm.annotation``' on
 any integer bit width.
 
 ::
 
-      declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32  <int>)
-      declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32  <int>)
+      declare i8 @llvm.annotation.i8(i8 <val>, ptr <str>, ptr <str>, i32  <int>)
+      declare i16 @llvm.annotation.i16(i16 <val>, ptr <str>, ptr <str>, i32  <int>)
+      declare i32 @llvm.annotation.i32(i32 <val>, ptr <str>, ptr <str>, i32  <int>)
+      declare i64 @llvm.annotation.i64(i64 <val>, ptr <str>, ptr <str>, i32  <int>)
+      declare i256 @llvm.annotation.i256(i256 <val>, ptr <str>, ptr <str>, i32  <int>)
 
 Overview:
 """""""""
 
 The '``llvm.annotation``' intrinsic.
 
 Arguments:
 """"""""""

 '``llvm.stackprotector``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare void @llvm.stackprotector(i8* <guard>, i8** <slot>)
+      declare void @llvm.stackprotector(ptr <guard>, ptr <slot>)
 
 Overview:
 """""""""
 
 The ``llvm.stackprotector`` intrinsic takes the ``guard`` and stores it
 onto the stack at ``slot``. The stack slot is adjusted to ensure that it
 is placed on the stack before local variables.
 

 '``llvm.stackguard``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.stackguard()
+      declare ptr @llvm.stackguard()
 
 Overview:
 """""""""
 
 The ``llvm.stackguard`` intrinsic returns the system stack guard value.
 
 It should not be generated by frontends, since it is only for internal usage.
 The reason why we create this intrinsic is that we still support IR form Stack

 '``llvm.objectsize``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i32 @llvm.objectsize.i32(i8* <object>, i1 <min>, i1 <nullunknown>, i1 <dynamic>)
-      declare i64 @llvm.objectsize.i64(i8* <object>, i1 <min>, i1 <nullunknown>, i1 <dynamic>)
+      declare i32 @llvm.objectsize.i32(ptr <object>, i1 <min>, i1 <nullunknown>, i1 <dynamic>)
+      declare i64 @llvm.objectsize.i64(ptr <object>, i1 <min>, i1 <nullunknown>, i1 <dynamic>)
 
 Overview:
 """""""""
 
 The ``llvm.objectsize`` intrinsic is designed to provide information to the
 optimizer to determine whether a) an operation (like memcpy) will overflow a
 buffer that corresponds to an object, or b) that a runtime check for overflow
 isn't necessary. An object in this context means an allocation of a specific

 '``llvm.type.test``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
+      declare i1 @llvm.type.test(ptr %ptr, metadata %type) nounwind readnone
 
 
 Arguments:
 """"""""""
 
 The first argument is a pointer to be tested. The second argument is a
 metadata object representing a :doc:`type identifier <TypeMetadata>`.
 
 Overview:
 """""""""
 
 The ``llvm.type.test`` intrinsic tests whether the given pointer is associated
 with the given type identifier.
 
 .. _type.checked.load:
 
 '``llvm.type.checked.load``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare {i8*, i1} @llvm.type.checked.load(i8* %ptr, i32 %offset, metadata %type) argmemonly nounwind readonly
+      declare {ptr, i1} @llvm.type.checked.load(ptr %ptr, i32 %offset, metadata %type) argmemonly nounwind readonly
 
 
 Arguments:
 """"""""""
 
 The first argument is a pointer from which to load a function pointer. The
 second argument is the byte offset from which to load the function pointer. The
 third argument is a metadata object representing a :doc:`type identifier

 '``llvm.load.relative``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      declare i8* @llvm.load.relative.iN(i8* %ptr, iN %offset) argmemonly nounwind readonly
+      declare ptr @llvm.load.relative.iN(ptr %ptr, iN %offset) argmemonly nounwind readonly
 
 Overview:
 """""""""
 
 This intrinsic loads a 32-bit value from the address ``%ptr + %offset``,
 adds ``%ptr`` to that value and returns it. The constant folder specifically
 recognizes the form of this intrinsic and the constant initializers it may
 load from; if a loaded constant initializer is known to have the form

 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.memcpy.element.unordered.atomic`` on
 any integer bit width and for different address spaces. Not all targets
 support all bit widths however.
 
 ::
 
-      declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* <dest>,
-                                                                       i8* <src>,
-                                                                       i32 <len>,
-                                                                       i32 <element_size>)
-      declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* <dest>,
-                                                                       i8* <src>,
-                                                                       i64 <len>,
-                                                                       i32 <element_size>)
+      declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i32(ptr <dest>,
+                                                                   ptr <src>,
+      declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr <dest>,
+                                                                   ptr <src>,
 
 Overview:
 """""""""
 
 The '``llvm.memcpy.element.unordered.atomic.*``' intrinsic is a specialization of the
 '``llvm.memcpy.*``' intrinsic. It differs in that the ``dest`` and ``src`` are treated
 as arrays with elements that are exactly ``element_size`` bytes, and the copy between
 buffers uses a sequence of :ref:`unordered atomic <ordering>` load/store operations

 """""""
 
 This is an overloaded intrinsic. You can use
 ``llvm.memmove.element.unordered.atomic`` on any integer bit width and for
 different address spaces. Not all targets support all bit widths however.
 
 ::
 
-      declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32(i8* <dest>,
-                                                                        i8* <src>,
-                                                                        i32 <len>,
-                                                                        i32 <element_size>)
-      declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* <dest>,
-                                                                        i8* <src>,
-                                                                        i64 <len>,
-                                                                        i32 <element_size>)
+      declare void @llvm.memmove.element.unordered.atomic.p0.p0.i32(ptr <dest>,
+                                                                    ptr <src>,
+      declare void @llvm.memmove.element.unordered.atomic.p0.p0.i64(ptr <dest>,
+                                                                    ptr <src>,
 
 Overview:
 """""""""
 
 The '``llvm.memmove.element.unordered.atomic.*``' intrinsic is a specialization
 of the '``llvm.memmove.*``' intrinsic. It differs in that the ``dest`` and
 ``src`` are treated as arrays with elements that are exactly ``element_size``
 bytes, and the copy between buffers uses a sequence of

 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.memset.element.unordered.atomic`` on
 any integer bit width and for different address spaces. Not all targets
 support all bit widths however.
 
 ::
 
-      declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* <dest>,
-                                                                  i8 <value>,
-                                                                  i32 <len>,
-                                                                  i32 <element_size>)
-      declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* <dest>,
-                                                                  i8 <value>,
-                                                                  i64 <len>,
-                                                                  i32 <element_size>)
+      declare void @llvm.memset.element.unordered.atomic.p0.i32(ptr <dest>,
+      declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr <dest>,
 
 Overview:
 """""""""
 
 The '``llvm.memset.element.unordered.atomic.*``' intrinsic is a specialization of the
 '``llvm.memset.*``' intrinsic. It differs in that the ``dest`` is treated as an array
 with elements that are exactly ``element_size`` bytes, and the assignment to that array
 uses uses a sequence of :ref:`unordered atomic <ordering>` store operations

 
 '``llvm.objc.autorelease``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.autorelease(i8*)
+      declare ptr @llvm.objc.autorelease(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_autorelease <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-autorelease>`_.
 
 '``llvm.objc.autoreleasePoolPop``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare void @llvm.objc.autoreleasePoolPop(i8*)
+      declare void @llvm.objc.autoreleasePoolPop(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_autoreleasePoolPop <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-autoreleasepoolpop-void-pool>`_.
 
 '``llvm.objc.autoreleasePoolPush``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.autoreleasePoolPush()
+      declare ptr @llvm.objc.autoreleasePoolPush()
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_autoreleasePoolPush <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-autoreleasepoolpush-void>`_.
 
 '``llvm.objc.autoreleaseReturnValue``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
+      declare ptr @llvm.objc.autoreleaseReturnValue(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_autoreleaseReturnValue <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-autoreleasereturnvalue>`_.
 
 '``llvm.objc.copyWeak``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare void @llvm.objc.copyWeak(i8**, i8**)
+      declare void @llvm.objc.copyWeak(ptr, ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_copyWeak <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-copyweak-id-dest-id-src>`_.
 
 '``llvm.objc.destroyWeak``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare void @llvm.objc.destroyWeak(i8**)
+      declare void @llvm.objc.destroyWeak(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_destroyWeak <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-destroyweak-id-object>`_.
 
 '``llvm.objc.initWeak``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.initWeak(i8**, i8*)
+      declare ptr @llvm.objc.initWeak(ptr, ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_initWeak <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-initweak>`_.
 
 '``llvm.objc.loadWeak``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.loadWeak(i8**)
+      declare ptr @llvm.objc.loadWeak(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_loadWeak <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-loadweak>`_.
 
 '``llvm.objc.loadWeakRetained``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.loadWeakRetained(i8**)
+      declare ptr @llvm.objc.loadWeakRetained(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_loadWeakRetained <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-loadweakretained>`_.
 
 '``llvm.objc.moveWeak``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare void @llvm.objc.moveWeak(i8**, i8**)
+      declare void @llvm.objc.moveWeak(ptr, ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_moveWeak <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-moveweak-id-dest-id-src>`_.
 
 '``llvm.objc.release``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare void @llvm.objc.release(i8*)
+      declare void @llvm.objc.release(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_release <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-release-id-value>`_.
 
 '``llvm.objc.retain``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.retain(i8*)
+      declare ptr @llvm.objc.retain(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_retain <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retain>`_.
 
 '``llvm.objc.retainAutorelease``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.retainAutorelease(i8*)
+      declare ptr @llvm.objc.retainAutorelease(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_retainAutorelease <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retainautorelease>`_.
 
 '``llvm.objc.retainAutoreleaseReturnValue``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.retainAutoreleaseReturnValue(i8*)
+      declare ptr @llvm.objc.retainAutoreleaseReturnValue(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_retainAutoreleaseReturnValue <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retainautoreleasereturnvalue>`_.
 
 '``llvm.objc.retainAutoreleasedReturnValue``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
+      declare ptr @llvm.objc.retainAutoreleasedReturnValue(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_retainAutoreleasedReturnValue <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retainautoreleasedreturnvalue>`_.
 
 '``llvm.objc.retainBlock``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.retainBlock(i8*)
+      declare ptr @llvm.objc.retainBlock(ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_retainBlock <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retainblock>`_.
 
 '``llvm.objc.storeStrong``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare void @llvm.objc.storeStrong(i8**, i8*)
+      declare void @llvm.objc.storeStrong(ptr, ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_storeStrong <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#void-objc-storestrong-id-object-id-value>`_.
 
 '``llvm.objc.storeWeak``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 ::
 
-      declare i8* @llvm.objc.storeWeak(i8**, i8*)
+      declare ptr @llvm.objc.storeWeak(ptr, ptr)
 
 Lowering:
 """""""""
 
 Lowers to a call to `objc_storeWeak <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-storeweak>`_.
 
 Preserving Debug Information Intrinsics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^