Add files using upload-large-folder tool

.gitattributes

@@ -1694,3 +1694,4 @@ vllm/lib/python3.10/site-packages/sympy/solvers/__pycache__/solvers.cpython-310.
 vllm/lib/python3.10/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/scipy/linalg/_solve_toeplitz.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/sympy/solvers/tests/__pycache__/test_solveset.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/sympy/solvers/ode/__pycache__/ode.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

vllm/lib/python3.10/site-packages/et_xmlfile/__init__.py

@@ -0,0 +1,8 @@
+from .xmlfile import xmlfile
+
+# constants
+__version__ = '2.0.0'
+__author__ = 'See AUTHORS.txt'
+__license__ = 'MIT'
+__author_email__ = 'charlie.clark@clark-consulting.eu'
+__url__ = 'https://foss.heptapod.net/openpyxl/et_xmlfile'

vllm/lib/python3.10/site-packages/et_xmlfile/incremental_tree.py

@@ -0,0 +1,917 @@
+# Code modified from cPython's Lib/xml/etree/ElementTree.py
+# The write() code is modified to allow specifying a particular namespace
+# uri -> prefix mapping.
+#
+# ---------------------------------------------------------------------
+# Licensed to PSF under a Contributor Agreement.
+# See https://www.python.org/psf/license for licensing details.
+#
+# ElementTree
+# Copyright (c) 1999-2008 by Fredrik Lundh.  All rights reserved.
+#
+# fredrik@pythonware.com
+# http://www.pythonware.com
+# --------------------------------------------------------------------
+# The ElementTree toolkit is
+#
+# Copyright (c) 1999-2008 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+import contextlib
+import io
+
+import xml.etree.ElementTree as ET
+
+
+def current_global_nsmap():
+    return {
+        prefix: uri for uri, prefix in ET._namespace_map.items()
+    }
+
+
+class IncrementalTree(ET.ElementTree):
+
+    def write(
+        self,
+        file_or_filename,
+        encoding=None,
+        xml_declaration=None,
+        default_namespace=None,
+        method=None,
+        *,
+        short_empty_elements=True,
+        nsmap=None,
+        root_ns_only=False,
+        minimal_ns_only=False,
+    ):
+        """Write element tree to a file as XML.
+
+        Arguments:
+          *file_or_filename* -- file name or a file object opened for writing
+
+          *encoding* -- the output encoding (default: US-ASCII)
+
+          *xml_declaration* -- bool indicating if an XML declaration should be
+                               added to the output. If None, an XML declaration
+                               is added if encoding IS NOT either of:
+                               US-ASCII, UTF-8, or Unicode
+
+          *default_namespace* -- sets the default XML namespace (for "xmlns").
+                                 Takes precedence over any default namespace
+                                 provided in nsmap or
+                                 xml.etree.ElementTree.register_namespace().
+
+          *method* -- either "xml" (default), "html, "text", or "c14n"
+
+          *short_empty_elements* -- controls the formatting of elements
+                                    that contain no content. If True (default)
+                                    they are emitted as a single self-closed
+                                    tag, otherwise they are emitted as a pair
+                                    of start/end tags
+
+          *nsmap* -- a mapping of namespace prefixes to URIs. These take
+                     precedence over any mappings registered using
+                     xml.etree.ElementTree.register_namespace(). The
+                     default_namespace argument, if supplied, takes precedence
+                     over any default namespace supplied in nsmap. All supplied
+                     namespaces will be declared on the root element, even if
+                     unused in the document.
+
+          *root_ns_only* -- bool indicating namespace declrations should only
+                            be written on the root element.  This requires two
+                            passes of the xml tree adding additional time to
+                            the writing process. This is primarily meant to
+                            mimic xml.etree.ElementTree's behaviour.
+
+          *minimal_ns_only* -- bool indicating only namespaces that were used
+                               to qualify elements or attributes should be
+                               declared. All namespace declarations will be
+                               written on the root element regardless of the
+                               value of the root_ns_only arg. Requires two
+                               passes of the xml tree adding additional time to
+                               the writing process.
+
+        """
+        if not method:
+            method = "xml"
+        elif method not in ("text", "xml", "html"):
+            raise ValueError("unknown method %r" % method)
+        if not encoding:
+            encoding = "us-ascii"
+
+        with _get_writer(file_or_filename, encoding) as (write, declared_encoding):
+            if method == "xml" and (
+                xml_declaration
+                or (
+                    xml_declaration is None
+                    and encoding.lower() != "unicode"
+                    and declared_encoding.lower() not in ("utf-8", "us-ascii")
+                )
+            ):
+                write("<?xml version='1.0' encoding='%s'?>\n" % (declared_encoding,))
+            if method == "text":
+                ET._serialize_text(write, self._root)
+            else:
+                if method == "xml":
+                    is_html = False
+                else:
+                    is_html = True
+                if nsmap:
+                    if None in nsmap:
+                        raise ValueError(
+                            'Found None as default nsmap prefix in nsmap. '
+                            'Use "" as the default namespace prefix.'
+                        )
+                    new_nsmap = nsmap.copy()
+                else:
+                    new_nsmap = {}
+                if default_namespace:
+                    new_nsmap[""] = default_namespace
+                if root_ns_only or minimal_ns_only:
+                    # _namespaces returns a mapping of only the namespaces that
+                    # were used.
+                    new_nsmap = _namespaces(
+                        self._root,
+                        default_namespace,
+                        new_nsmap,
+                    )
+                    if not minimal_ns_only:
+                        if nsmap:
+                            # We want all namespaces defined in the provided
+                            # nsmap to be declared regardless of whether
+                            # they've been used.
+                            new_nsmap.update(nsmap)
+                        if default_namespace:
+                            new_nsmap[""] = default_namespace
+                global_nsmap = {
+                    prefix: uri for uri, prefix in ET._namespace_map.items()
+                }
+                if None in global_nsmap:
+                    raise ValueError(
+                        'Found None as default nsmap prefix in nsmap registered with '
+                        'register_namespace. Use "" for the default namespace prefix.'
+                    )
+                nsmap_scope = {}
+                _serialize_ns_xml(
+                    write,
+                    self._root,
+                    nsmap_scope,
+                    global_nsmap,
+                    is_html=is_html,
+                    is_root=True,
+                    short_empty_elements=short_empty_elements,
+                    new_nsmap=new_nsmap,
+                )
+
+
+def _make_new_ns_prefix(
+    nsmap_scope,
+    global_prefixes,
+    local_nsmap=None,
+    default_namespace=None,
+):
+    i = len(nsmap_scope)
+    if default_namespace is not None and "" not in nsmap_scope:
+        # Keep the same numbering scheme as python which assumes the default
+        # namespace is present if supplied.
+        i += 1
+
+    while True:
+        prefix = f"ns{i}"
+        if (
+            prefix not in nsmap_scope
+            and prefix not in global_prefixes
+            and (
+                not local_nsmap or prefix not in local_nsmap
+            )
+        ):
+            return prefix
+        i += 1
+
+
+def _get_or_create_prefix(
+    uri,
+    nsmap_scope,
+    global_nsmap,
+    new_namespace_prefixes,
+    uri_to_prefix,
+    for_default_namespace_attr_prefix=False,
+):
+    """Find a prefix that doesn't conflict with the ns scope or create a new prefix
+
+    This function mutates nsmap_scope, global_nsmap, new_namespace_prefixes and
+    uri_to_prefix. It is intended to keep state in _serialize_ns_xml consistent
+    while deduplicating the house keeping code or updating these dictionaries.
+    """
+    # Check if we can reuse an existing (global) prefix within the current
+    # namespace scope. There maybe many prefixes pointing to a single URI by
+    # this point and we need to select a prefix that is not in use in the
+    # current scope.
+    for global_prefix, global_uri in global_nsmap.items():
+        if uri == global_uri and global_prefix not in nsmap_scope:
+            prefix = global_prefix
+            break
+    else:  # no break
+        # We couldn't find a suitable existing prefix for this namespace scope,
+        # let's create a new one.
+        prefix = _make_new_ns_prefix(nsmap_scope, global_prefixes=global_nsmap)
+        global_nsmap[prefix] = uri
+    nsmap_scope[prefix] = uri
+    if not for_default_namespace_attr_prefix:
+        # Don't override the actual default namespace prefix
+        uri_to_prefix[uri] = prefix
+    if prefix != "xml":
+        new_namespace_prefixes.add(prefix)
+    return prefix
+
+
+def _find_default_namespace_attr_prefix(
+    default_namespace,
+    nsmap,
+    local_nsmap,
+    global_prefixes,
+    provided_default_namespace=None,
+):
+    # Search the provided nsmap for any prefixes for this uri that aren't the
+    # default namespace ""
+    for prefix, uri in nsmap.items():
+        if uri == default_namespace and prefix != "":
+            return prefix
+
+    for prefix, uri in local_nsmap.items():
+        if uri == default_namespace and prefix != "":
+            return prefix
+
+    # _namespace_map is a 1:1 mapping of uri -> prefix
+    prefix = ET._namespace_map.get(default_namespace)
+    if prefix and prefix not in nsmap:
+        return prefix
+
+    return _make_new_ns_prefix(
+        nsmap,
+        global_prefixes,
+        local_nsmap,
+        provided_default_namespace,
+    )
+
+
+def process_attribs(
+    elem,
+    is_nsmap_scope_changed,
+    default_ns_attr_prefix,
+    nsmap_scope,
+    global_nsmap,
+    new_namespace_prefixes,
+    uri_to_prefix,
+):
+    item_parts = []
+    for k, v in elem.items():
+        if isinstance(k, ET.QName):
+            k = k.text
+        try:
+            if k[:1] == "{":
+                uri_and_name = k[1:].rsplit("}", 1)
+                try:
+                    prefix = uri_to_prefix[uri_and_name[0]]
+                except KeyError:
+                    if not is_nsmap_scope_changed:
+                        # We're about to mutate the these dicts so
+                        # let's copy them first. We don't have to
+                        # recompute other mappings as we're looking up
+                        # or creating a new prefix
+                        nsmap_scope = nsmap_scope.copy()
+                        uri_to_prefix = uri_to_prefix.copy()
+                        is_nsmap_scope_changed = True
+                    prefix = _get_or_create_prefix(
+                        uri_and_name[0],
+                        nsmap_scope,
+                        global_nsmap,
+                        new_namespace_prefixes,
+                        uri_to_prefix,
+                    )
+
+                if not prefix:
+                    if default_ns_attr_prefix:
+                        prefix = default_ns_attr_prefix
+                    else:
+                        for prefix, known_uri in nsmap_scope.items():
+                            if known_uri == uri_and_name[0] and prefix != "":
+                                default_ns_attr_prefix = prefix
+                                break
+                        else:  # no break
+                            if not is_nsmap_scope_changed:
+                                # We're about to mutate the these dicts so
+                                # let's copy them first. We don't have to
+                                # recompute other mappings as we're looking up
+                                # or creating a new prefix
+                                nsmap_scope = nsmap_scope.copy()
+                                uri_to_prefix = uri_to_prefix.copy()
+                                is_nsmap_scope_changed = True
+                            prefix = _get_or_create_prefix(
+                                uri_and_name[0],
+                                nsmap_scope,
+                                global_nsmap,
+                                new_namespace_prefixes,
+                                uri_to_prefix,
+                                for_default_namespace_attr_prefix=True,
+                            )
+                            default_ns_attr_prefix = prefix
+                k = f"{prefix}:{uri_and_name[1]}"
+        except TypeError:
+            ET._raise_serialization_error(k)
+
+        if isinstance(v, ET.QName):
+            if v.text[:1] != "{":
+                v = v.text
+            else:
+                uri_and_name = v.text[1:].rsplit("}", 1)
+                try:
+                    prefix = uri_to_prefix[uri_and_name[0]]
+                except KeyError:
+                    if not is_nsmap_scope_changed:
+                        # We're about to mutate the these dicts so
+                        # let's copy them first. We don't have to
+                        # recompute other mappings as we're looking up
+                        # or creating a new prefix
+                        nsmap_scope = nsmap_scope.copy()
+                        uri_to_prefix = uri_to_prefix.copy()
+                        is_nsmap_scope_changed = True
+                    prefix = _get_or_create_prefix(
+                        uri_and_name[0],
+                        nsmap_scope,
+                        global_nsmap,
+                        new_namespace_prefixes,
+                        uri_to_prefix,
+                    )
+                v = f"{prefix}:{uri_and_name[1]}"
+        item_parts.append((k, v))
+    return item_parts, default_ns_attr_prefix, nsmap_scope
+
+
+def write_elem_start(
+    write,
+    elem,
+    nsmap_scope,
+    global_nsmap,
+    short_empty_elements,
+    is_html,
+    is_root=False,
+    uri_to_prefix=None,
+    default_ns_attr_prefix=None,
+    new_nsmap=None,
+    **kwargs,
+):
+    """Write the opening tag (including self closing) and element text.
+
+    Refer to _serialize_ns_xml for description of arguments.
+
+    nsmap_scope should be an empty dictionary on first call. All nsmap prefixes
+    must be strings with the default namespace prefix represented by "".
+
+    eg.
+    - <foo attr1="one">      (returns tag = 'foo')
+    - <foo attr1="one">text  (returns tag = 'foo')
+    - <foo attr1="one" />    (returns tag = None)
+
+    Returns:
+        tag:
+            The tag name to be closed or None if no closing required.
+        nsmap_scope:
+            The current nsmap after any prefix to uri additions from this
+            element. This is the input dict if unmodified or an updated copy.
+        default_ns_attr_prefix:
+            The prefix for the default namespace to use with attrs.
+        uri_to_prefix:
+            The current uri to prefix map after any uri to prefix additions
+            from this element. This is the input dict if unmodified or an
+            updated copy.
+        next_remains_root:
+            A bool indicating if the child element(s) should be treated as
+            their own roots.
+    """
+    tag = elem.tag
+    text = elem.text
+
+    if tag is ET.Comment:
+        write("<!--%s-->" % text)
+        tag = None
+        next_remains_root = False
+    elif tag is ET.ProcessingInstruction:
+        write("<?%s?>" % text)
+        tag = None
+        next_remains_root = False
+    else:
+        if new_nsmap:
+            is_nsmap_scope_changed = True
+            nsmap_scope = nsmap_scope.copy()
+            nsmap_scope.update(new_nsmap)
+            new_namespace_prefixes = set(new_nsmap.keys())
+            new_namespace_prefixes.discard("xml")
+            # We need to recompute the uri to prefixes
+            uri_to_prefix = None
+            default_ns_attr_prefix = None
+        else:
+            is_nsmap_scope_changed = False
+            new_namespace_prefixes = set()
+
+        if uri_to_prefix is None:
+            if None in nsmap_scope:
+                raise ValueError(
+                    'Found None as a namespace prefix. Use "" as the default namespace prefix.'
+                )
+            uri_to_prefix = {uri: prefix for prefix, uri in nsmap_scope.items()}
+            if "" in nsmap_scope:
+                # There may be multiple prefixes for the default namespace but
+                # we want to make sure we preferentially use "" (for elements)
+                uri_to_prefix[nsmap_scope[""]] = ""
+
+        if tag is None:
+            # tag supression where tag is set to None
+            # Don't change is_root so namespaces can be passed down
+            next_remains_root = is_root
+            if text:
+                write(ET._escape_cdata(text))
+        else:
+            next_remains_root = False
+            if isinstance(tag, ET.QName):
+                tag = tag.text
+            try:
+                # These splits / fully qualified tag creationg are the
+                # bottleneck in this implementation vs the python
+                # implementation.
+                # The following split takes ~42ns with no uri and ~85ns if a
+                # prefix is present. If the uri was present, we then need to
+                # look up a prefix (~14ns) and create the fully qualified
+                # string (~41ns).  This gives a total of ~140ns where a uri is
+                # present.
+                # Python's implementation needs to preprocess the tree to
+                # create a dict of qname -> tag by traversing the tree which
+                # takes a bit of extra time but it quickly makes that back by
+                # only having to do a dictionary look up (~14ns) for each tag /
+                # attrname vs our splitting (~140ns).
+                # So here we have the flexibility of being able to redefine the
+                # uri a prefix points to midway through serialisation at the
+                # expense of performance (~10% slower for a 1mb file on my
+                # machine).
+                if tag[:1] == "{":
+                    uri_and_name = tag[1:].rsplit("}", 1)
+                    try:
+                        prefix = uri_to_prefix[uri_and_name[0]]
+                    except KeyError:
+                        if not is_nsmap_scope_changed:
+                            # We're about to mutate the these dicts so let's
+                            # copy them first. We don't have to recompute other
+                            # mappings as we're looking up or creating a new
+                            # prefix
+                            nsmap_scope = nsmap_scope.copy()
+                            uri_to_prefix = uri_to_prefix.copy()
+                            is_nsmap_scope_changed = True
+                        prefix = _get_or_create_prefix(
+                            uri_and_name[0],
+                            nsmap_scope,
+                            global_nsmap,
+                            new_namespace_prefixes,
+                            uri_to_prefix,
+                        )
+                    if prefix:
+                        tag = f"{prefix}:{uri_and_name[1]}"
+                    else:
+                        tag = uri_and_name[1]
+                elif "" in nsmap_scope:
+                    raise ValueError(
+                        "cannot use non-qualified names with default_namespace option"
+                    )
+            except TypeError:
+                ET._raise_serialization_error(tag)
+
+            write("<" + tag)
+
+            if elem.attrib:
+                item_parts, default_ns_attr_prefix, nsmap_scope = process_attribs(
+                    elem,
+                    is_nsmap_scope_changed,
+                    default_ns_attr_prefix,
+                    nsmap_scope,
+                    global_nsmap,
+                    new_namespace_prefixes,
+                    uri_to_prefix,
+                )
+            else:
+                item_parts = []
+            if new_namespace_prefixes:
+                ns_attrs = []
+                for k in sorted(new_namespace_prefixes):
+                    v = nsmap_scope[k]
+                    if k:
+                        k = "xmlns:" + k
+                    else:
+                        k = "xmlns"
+                    ns_attrs.append((k, v))
+                if is_html:
+                    write("".join([f' {k}="{ET._escape_attrib_html(v)}"' for k, v in ns_attrs]))
+                else:
+                    write("".join([f' {k}="{ET._escape_attrib(v)}"' for k, v in ns_attrs]))
+            if item_parts:
+                if is_html:
+                    write("".join([f' {k}="{ET._escape_attrib_html(v)}"' for k, v in item_parts]))
+                else:
+                    write("".join([f' {k}="{ET._escape_attrib(v)}"' for k, v in item_parts]))
+            if is_html:
+                write(">")
+                ltag = tag.lower()
+                if text:
+                    if ltag == "script" or ltag == "style":
+                        write(text)
+                    else:
+                        write(ET._escape_cdata(text))
+                if ltag in ET.HTML_EMPTY:
+                    tag = None
+            elif text or len(elem) or not short_empty_elements:
+                write(">")
+                if text:
+                    write(ET._escape_cdata(text))
+            else:
+                tag = None
+                write(" />")
+    return (
+        tag,
+        nsmap_scope,
+        default_ns_attr_prefix,
+        uri_to_prefix,
+        next_remains_root,
+    )
+
+
+def _serialize_ns_xml(
+    write,
+    elem,
+    nsmap_scope,
+    global_nsmap,
+    short_empty_elements,
+    is_html,
+    is_root=False,
+    uri_to_prefix=None,
+    default_ns_attr_prefix=None,
+    new_nsmap=None,
+    **kwargs,
+):
+    """Serialize an element or tree using 'write' for output.
+
+    Args:
+        write:
+            A function to write the xml to its destination.
+        elem:
+            The element to serialize.
+        nsmap_scope:
+            The current prefix to uri mapping for this element. This should be
+            an empty dictionary for the root element. Additional namespaces are
+            progressively added using the new_nsmap arg.
+        global_nsmap:
+            A dict copy of the globally registered _namespace_map in uri to
+            prefix form
+        short_empty_elements:
+          Controls the formatting of elements that contain no content. If True
+          (default) they are emitted as a single self-closed tag, otherwise
+          they are emitted as a pair of start/end tags.
+        is_html:
+            Set to True to serialize as HTML otherwise XML.
+        is_root:
+            Boolean indicating if this is a root element.
+        uri_to_prefix:
+            Current state of the mapping of uri to prefix.
+        default_ns_attr_prefix:
+        new_nsmap:
+            New prefix -> uri mapping to be applied to this element.
+    """
+    (
+        tag,
+        nsmap_scope,
+        default_ns_attr_prefix,
+        uri_to_prefix,
+        next_remains_root,
+    ) = write_elem_start(
+        write,
+        elem,
+        nsmap_scope,
+        global_nsmap,
+        short_empty_elements,
+        is_html,
+        is_root,
+        uri_to_prefix,
+        default_ns_attr_prefix,
+        new_nsmap=new_nsmap,
+    )
+    for e in elem:
+        _serialize_ns_xml(
+            write,
+            e,
+            nsmap_scope,
+            global_nsmap,
+            short_empty_elements,
+            is_html,
+            next_remains_root,
+            uri_to_prefix,
+            default_ns_attr_prefix,
+            new_nsmap=None,
+        )
+    if tag:
+        write(f"</{tag}>")
+    if elem.tail:
+        write(ET._escape_cdata(elem.tail))
+
+
+def _qnames_iter(elem):
+    """Iterate through all the qualified names in elem"""
+    seen_el_qnames = set()
+    seen_other_qnames = set()
+    for this_elem in elem.iter():
+        tag = this_elem.tag
+        if isinstance(tag, str):
+            if tag not in seen_el_qnames:
+                seen_el_qnames.add(tag)
+                yield tag, True
+        elif isinstance(tag, ET.QName):
+            tag = tag.text
+            if tag not in seen_el_qnames:
+                seen_el_qnames.add(tag)
+                yield tag, True
+        elif (
+            tag is not None
+            and tag is not ET.ProcessingInstruction
+            and tag is not ET.Comment
+        ):
+            ET._raise_serialization_error(tag)
+
+        for key, value in this_elem.items():
+            if isinstance(key, ET.QName):
+                key = key.text
+            if key not in seen_other_qnames:
+                seen_other_qnames.add(key)
+                yield key, False
+
+            if isinstance(value, ET.QName):
+                if value.text not in seen_other_qnames:
+                    seen_other_qnames.add(value.text)
+                    yield value.text, False
+
+        text = this_elem.text
+        if isinstance(text, ET.QName):
+            if text.text not in seen_other_qnames:
+                seen_other_qnames.add(text.text)
+                yield text.text, False
+
+
+def _namespaces(
+    elem,
+    default_namespace=None,
+    nsmap=None,
+):
+    """Find all namespaces used in the document and return a prefix to uri map"""
+    if nsmap is None:
+        nsmap = {}
+
+    out_nsmap = {}
+
+    seen_uri_to_prefix = {}
+    # Multiple prefixes may be present for a single uri. This will select the
+    # last prefix found in nsmap for a given uri.
+    local_prefix_map = {uri: prefix for prefix, uri in nsmap.items()}
+    if default_namespace is not None:
+        local_prefix_map[default_namespace] = ""
+    elif "" in nsmap:
+        # but we make sure the default prefix always take precedence
+        local_prefix_map[nsmap[""]] = ""
+
+    global_prefixes = set(ET._namespace_map.values())
+    has_unqual_el = False
+    default_namespace_attr_prefix = None
+    for qname, is_el in _qnames_iter(elem):
+        try:
+            if qname[:1] == "{":
+                uri_and_name = qname[1:].rsplit("}", 1)
+
+                prefix = seen_uri_to_prefix.get(uri_and_name[0])
+                if prefix is None:
+                    prefix = local_prefix_map.get(uri_and_name[0])
+                    if prefix is None or prefix in out_nsmap:
+                        prefix = ET._namespace_map.get(uri_and_name[0])
+                        if prefix is None or prefix in out_nsmap:
+                            prefix = _make_new_ns_prefix(
+                                out_nsmap,
+                                global_prefixes,
+                                nsmap,
+                                default_namespace,
+                            )
+                    if prefix or is_el:
+                        out_nsmap[prefix] = uri_and_name[0]
+                        seen_uri_to_prefix[uri_and_name[0]] = prefix
+
+                if not is_el and not prefix and not default_namespace_attr_prefix:
+                    # Find the alternative prefix to use with non-element
+                    # names
+                    default_namespace_attr_prefix = _find_default_namespace_attr_prefix(
+                        uri_and_name[0],
+                        out_nsmap,
+                        nsmap,
+                        global_prefixes,
+                        default_namespace,
+                    )
+                    out_nsmap[default_namespace_attr_prefix] = uri_and_name[0]
+                    # Don't add this uri to prefix mapping as it might override
+                    # the uri -> "" default mapping. We'll fix this up at the
+                    # end of the fn.
+                    # local_prefix_map[uri_and_name[0]] = default_namespace_attr_prefix
+            else:
+                if is_el:
+                    has_unqual_el = True
+        except TypeError:
+            ET._raise_serialization_error(qname)
+
+    if "" in out_nsmap and has_unqual_el:
+        # FIXME: can this be handled in XML 1.0?
+        raise ValueError(
+            "cannot use non-qualified names with default_namespace option"
+        )
+
+    # The xml prefix doesn't need to be declared but may have been used to
+    # prefix names. Let's remove it if it has been used
+    out_nsmap.pop("xml", None)
+    return out_nsmap
+
+
+def tostring(
+    element,
+    encoding=None,
+    method=None,
+    *,
+    xml_declaration=None,
+    default_namespace=None,
+    short_empty_elements=True,
+    nsmap=None,
+    root_ns_only=False,
+    minimal_ns_only=False,
+    tree_cls=IncrementalTree,
+):
+    """Generate string representation of XML element.
+
+    All subelements are included.  If encoding is "unicode", a string
+    is returned. Otherwise a bytestring is returned.
+
+    *element* is an Element instance, *encoding* is an optional output
+    encoding defaulting to US-ASCII, *method* is an optional output which can
+    be one of "xml" (default), "html", "text" or "c14n", *default_namespace*
+    sets the default XML namespace (for "xmlns").
+
+    Returns an (optionally) encoded string containing the XML data.
+
+    """
+    stream = io.StringIO() if encoding == "unicode" else io.BytesIO()
+    tree_cls(element).write(
+        stream,
+        encoding,
+        xml_declaration=xml_declaration,
+        default_namespace=default_namespace,
+        method=method,
+        short_empty_elements=short_empty_elements,
+        nsmap=nsmap,
+        root_ns_only=root_ns_only,
+        minimal_ns_only=minimal_ns_only,
+    )
+    return stream.getvalue()
+
+
+def tostringlist(
+    element,
+    encoding=None,
+    method=None,
+    *,
+    xml_declaration=None,
+    default_namespace=None,
+    short_empty_elements=True,
+    nsmap=None,
+    root_ns_only=False,
+    minimal_ns_only=False,
+    tree_cls=IncrementalTree,
+):
+    lst = []
+    stream = ET._ListDataStream(lst)
+    tree_cls(element).write(
+        stream,
+        encoding,
+        xml_declaration=xml_declaration,
+        default_namespace=default_namespace,
+        method=method,
+        short_empty_elements=short_empty_elements,
+        nsmap=nsmap,
+        root_ns_only=root_ns_only,
+        minimal_ns_only=minimal_ns_only,
+    )
+    return lst
+
+
+def compat_tostring(
+    element,
+    encoding=None,
+    method=None,
+    *,
+    xml_declaration=None,
+    default_namespace=None,
+    short_empty_elements=True,
+    nsmap=None,
+    root_ns_only=True,
+    minimal_ns_only=False,
+    tree_cls=IncrementalTree,
+):
+    """tostring with options that produce the same results as xml.etree.ElementTree.tostring
+
+    root_ns_only=True is a bit slower than False as it needs to traverse the
+    tree one more time to collect all the namespaces.
+    """
+    return tostring(
+        element,
+        encoding=encoding,
+        method=method,
+        xml_declaration=xml_declaration,
+        default_namespace=default_namespace,
+        short_empty_elements=short_empty_elements,
+        nsmap=nsmap,
+        root_ns_only=root_ns_only,
+        minimal_ns_only=minimal_ns_only,
+        tree_cls=tree_cls,
+    )
+
+
+# --------------------------------------------------------------------
+# serialization support
+
+@contextlib.contextmanager
+def _get_writer(file_or_filename, encoding):
+    # Copied from Python 3.12
+    # returns text write method and release all resources after using
+    try:
+        write = file_or_filename.write
+    except AttributeError:
+        # file_or_filename is a file name
+        if encoding.lower() == "unicode":
+            encoding = "utf-8"
+        with open(file_or_filename, "w", encoding=encoding,
+                  errors="xmlcharrefreplace") as file:
+            yield file.write, encoding
+    else:
+        # file_or_filename is a file-like object
+        # encoding determines if it is a text or binary writer
+        if encoding.lower() == "unicode":
+            # use a text writer as is
+            yield write, getattr(file_or_filename, "encoding", None) or "utf-8"
+        else:
+            # wrap a binary writer with TextIOWrapper
+            with contextlib.ExitStack() as stack:
+                if isinstance(file_or_filename, io.BufferedIOBase):
+                    file = file_or_filename
+                elif isinstance(file_or_filename, io.RawIOBase):
+                    file = io.BufferedWriter(file_or_filename)
+                    # Keep the original file open when the BufferedWriter is
+                    # destroyed
+                    stack.callback(file.detach)
+                else:
+                    # This is to handle passed objects that aren't in the
+                    # IOBase hierarchy, but just have a write method
+                    file = io.BufferedIOBase()
+                    file.writable = lambda: True
+                    file.write = write
+                    try:
+                        # TextIOWrapper uses this methods to determine
+                        # if BOM (for UTF-16, etc) should be added
+                        file.seekable = file_or_filename.seekable
+                        file.tell = file_or_filename.tell
+                    except AttributeError:
+                        pass
+                file = io.TextIOWrapper(file,
+                                        encoding=encoding,
+                                        errors="xmlcharrefreplace",
+                                        newline="\n")
+                # Keep the original file open when the TextIOWrapper is
+                # destroyed
+                stack.callback(file.detach)
+                yield file.write, encoding

vllm/lib/python3.10/site-packages/et_xmlfile/xmlfile.py

@@ -0,0 +1,158 @@
+from __future__ import absolute_import
+# Copyright (c) 2010-2015 openpyxl
+
+"""Implements the lxml.etree.xmlfile API using the standard library xml.etree"""
+
+
+from contextlib import contextmanager
+
+from xml.etree.ElementTree import (
+    Element,
+    _escape_cdata,
+)
+
+from . import incremental_tree
+
+
+class LxmlSyntaxError(Exception):
+    pass
+
+
+class _IncrementalFileWriter(object):
+    """Replacement for _IncrementalFileWriter of lxml"""
+    def __init__(self, output_file):
+        self._element_stack = []
+        self._file = output_file
+        self._have_root = False
+        self.global_nsmap = incremental_tree.current_global_nsmap()
+        self.is_html = False
+
+    @contextmanager
+    def element(self, tag, attrib=None, nsmap=None, **_extra):
+        """Create a new xml element using a context manager."""
+        if nsmap and None in nsmap:
+            # Normalise None prefix (lxml's default namespace prefix) -> "", as
+            # required for incremental_tree
+            if "" in nsmap and nsmap[""] != nsmap[None]:
+                raise ValueError(
+                    'Found None and "" as default nsmap prefixes with different URIs'
+                )
+            nsmap = nsmap.copy()
+            nsmap[""] = nsmap.pop(None)
+
+        # __enter__ part
+        self._have_root = True
+        if attrib is None:
+            attrib = {}
+        elem = Element(tag, attrib=attrib, **_extra)
+        elem.text = ''
+        elem.tail = ''
+        if self._element_stack:
+            is_root = False
+            (
+                nsmap_scope,
+                default_ns_attr_prefix,
+                uri_to_prefix,
+            ) = self._element_stack[-1]
+        else:
+            is_root = True
+            nsmap_scope = {}
+            default_ns_attr_prefix = None
+            uri_to_prefix = {}
+        (
+            tag,
+            nsmap_scope,
+            default_ns_attr_prefix,
+            uri_to_prefix,
+            next_remains_root,
+        ) = incremental_tree.write_elem_start(
+            self._file,
+            elem,
+            nsmap_scope=nsmap_scope,
+            global_nsmap=self.global_nsmap,
+            short_empty_elements=False,
+            is_html=self.is_html,
+            is_root=is_root,
+            uri_to_prefix=uri_to_prefix,
+            default_ns_attr_prefix=default_ns_attr_prefix,
+            new_nsmap=nsmap,
+        )
+        self._element_stack.append(
+            (
+                nsmap_scope,
+                default_ns_attr_prefix,
+                uri_to_prefix,
+            )
+        )
+        yield
+
+        # __exit__ part
+        self._element_stack.pop()
+        self._file(f"</{tag}>")
+        if elem.tail:
+            self._file(_escape_cdata(elem.tail))
+
+    def write(self, arg):
+        """Write a string or subelement."""
+
+        if isinstance(arg, str):
+            # it is not allowed to write a string outside of an element
+            if not self._element_stack:
+                raise LxmlSyntaxError()
+            self._file(_escape_cdata(arg))
+
+        else:
+            if not self._element_stack and self._have_root:
+                raise LxmlSyntaxError()
+
+            if self._element_stack:
+                is_root = False
+                (
+                    nsmap_scope,
+                    default_ns_attr_prefix,
+                    uri_to_prefix,
+                ) = self._element_stack[-1]
+            else:
+                is_root = True
+                nsmap_scope = {}
+                default_ns_attr_prefix = None
+                uri_to_prefix = {}
+            incremental_tree._serialize_ns_xml(
+                self._file,
+                arg,
+                nsmap_scope=nsmap_scope,
+                global_nsmap=self.global_nsmap,
+                short_empty_elements=True,
+                is_html=self.is_html,
+                is_root=is_root,
+                uri_to_prefix=uri_to_prefix,
+                default_ns_attr_prefix=default_ns_attr_prefix,
+            )
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, type, value, traceback):
+        # without root the xml document is incomplete
+        if not self._have_root:
+            raise LxmlSyntaxError()
+
+
+class xmlfile(object):
+    """Context manager that can replace lxml.etree.xmlfile."""
+    def __init__(self, output_file, buffered=False, encoding="utf-8", close=False):
+        self._file = output_file
+        self._close = close
+        self.encoding = encoding
+        self.writer_cm = None
+
+    def __enter__(self):
+        self.writer_cm = incremental_tree._get_writer(self._file, encoding=self.encoding)
+        writer, declared_encoding = self.writer_cm.__enter__()
+        return _IncrementalFileWriter(writer)
+
+    def __exit__(self, type, value, traceback):
+        if self.writer_cm:
+            self.writer_cm.__exit__(type, value, traceback)
+        if self._close:
+            self._file.close()

vllm/lib/python3.10/site-packages/fastrlock-0.8.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vllm/lib/python3.10/site-packages/fastrlock-0.8.3.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 scoder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vllm/lib/python3.10/site-packages/fastrlock-0.8.3.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.1
+Name: fastrlock
+Version: 0.8.3
+Summary: Fast, re-entrant optimistic lock implemented in Cython
+Home-page: https://github.com/scoder/fastrlock
+Author: Stefan Behnel
+Author-email: stefan_ml@behnel.de
+License: MIT style
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development
+License-File: LICENSE
+
+FastRLock
+---------
+
+This is a C-level implementation of a fast, re-entrant, optimistic lock for CPython.
+It is a drop-in replacement for
+`threading.RLock <https://docs.python.org/3/library/threading.html#threading.RLock>`_.
+FastRLock is implemented in `Cython <https://cython.org>`_ and also provides a C-API
+for direct use from Cython code via ``from fastrlock cimport rlock`` or
+``from cython.cimports.fastrlock import rlock``.
+
+Under normal conditions, it is about 10x faster than ``threading.RLock`` in Python 2.7
+because it avoids all locking unless two or more threads try to acquire it at the
+same time.  Under congestion, it is still about 10% faster than RLock due to being
+implemented in Cython.
+
+This is mostly equivalent to the revised RLock implementation in Python 3.2,
+but still faster due to being implemented in Cython.  However, in Python 3.4 and
+later, the ``threading.RLock`` implementation in the stdlib tends to be as fast
+or even faster than the lock provided by this package, when called through the
+Python API.  ``FastRLock`` is still faster also on these systems when called
+through its Cython API from other Cython modules.
+
+It was initially published as a code recipe here:
+https://code.activestate.com/recipes/577336-fast-re-entrant-optimistic-lock-implemented-in-cyt/
+
+FastRLock has been used and tested in `Lupa <https://github.com/scoder/lupa>`_ for several years.
+
+
+How does it work?
+-----------------
+
+The FastRLock implementation optimises for the non-congested case.  It works by
+exploiting the availability of the GIL.  Since it knows that it holds the GIL when
+the acquire()/release() methods are called, it can safely check the lock for being
+held by other threads and just count any re-entries as long as it is always the
+same thread that acquires it.  This is a lot faster than actually acquiring the
+underlying lock.
+
+When a second thread wants to acquire the lock as well, it first checks the lock
+count and finds out that the lock is already owned.  If the underlying lock is also
+held by another thread already, it then just frees the GIL and asks for acquiring
+the lock, just like RLock does.  If the underlying lock is not held, however, it
+acquires it immediately and basically hands over the ownership by telling the
+current owner to free it when it's done.  Then, it falls back to the normal
+non-owner behaviour that asks for the lock and will eventually acquire it when it
+gets released.  This makes sure that the real lock is only acquired when at least
+two threads want it.
+
+All of these operations are basically atomic because any thread that modifies the
+lock state always holds the GIL.  Note that the implementation must not call any
+Python code while handling the lock, as calling into Python may lead to a context
+switch which hands over the GIL to another thread and thus breaks atomicity.
+Therefore, the code misuses Cython's 'nogil' annotation to make sure that no Python
+code slips in accidentally.
+
+
+How fast is it?
+---------------
+
+Here are some timings for the following scenarios:
+
+1) five acquire-release cycles ('lock_unlock')
+2) five acquire calls followed by five release calls (nested locking, 'reentrant_lock_unlock')
+3) a mixed and partly nested sequence of acquire and release calls ('mixed_lock_unlock')
+4) five acquire-release cycles that do not block ('lock_unlock_nonblocking')
+
+All four are benchmarked for the single threaded case and the multi threaded case
+with 10 threads.  I also tested it with 20 threads only to see that it then takes
+about twice the time for both versions.  Note also that the congested case is
+substantially slower for both locks and the benchmark includes the thread
+creation time, so I only looped 1000x here to get useful
+timings instead of 100000x for the single threaded case.
+
+The results here are mixed.  Depending on the optimisation of the CPython
+installation, it can be faster, about the same speed, or somewhat slower.
+In any case, the direct Cython interface is always faster than going through
+the Python API, because it avoids the Python call overhead and executes
+a C call instead.
+
+::
+
+    Testing RLock (3.10.1)
+
+    sequential (x100000):
+    lock_unlock              :    138.36 msec
+    reentrant_lock_unlock    :     95.35 msec
+    mixed_lock_unlock        :    102.05 msec
+    lock_unlock_nonblocking  :    131.44 msec
+    context_manager          :    616.83 msec
+
+    threaded 10T (x1000):
+    lock_unlock              :   1386.60 msec
+    reentrant_lock_unlock    :   1207.75 msec
+    mixed_lock_unlock        :   1319.62 msec
+    lock_unlock_nonblocking  :   1325.07 msec
+    context_manager          :   1357.93 msec
+
+    Testing FastRLock (0.8.1)
+
+    sequential (x100000):
+    lock_unlock              :     77.47 msec
+    reentrant_lock_unlock    :     64.14 msec
+    mixed_lock_unlock        :     73.51 msec
+    lock_unlock_nonblocking  :     70.31 msec
+    context_manager          :    393.34 msec
+
+    threaded 10T (x1000):
+    lock_unlock              :   1214.13 msec
+    reentrant_lock_unlock    :   1171.75 msec
+    mixed_lock_unlock        :   1184.33 msec
+    lock_unlock_nonblocking  :   1207.42 msec
+    context_manager          :   1232.20 msec
+
+    Testing Cython interface of FastRLock (0.8.1)
+
+    sequential (x100000):
+    lock_unlock              :     18.70 msec
+    reentrant_lock_unlock    :     15.88 msec
+    mixed_lock_unlock        :     14.96 msec
+    lock_unlock_nonblocking  :     13.47 msec
+
+    threaded 10T (x1000):
+    lock_unlock              :   1236.21 msec
+    reentrant_lock_unlock    :   1245.77 msec
+    mixed_lock_unlock        :   1194.25 msec
+    lock_unlock_nonblocking  :   1206.96 msec
+
+
+===================
+fastrlock changelog
+===================
+
+0.8.3 (2024-12-17)
+==================
+
+* Rebuilt with Cython 3.0.11 to add Python 3.13 support.
+
+
+0.8.2 (2023-08-27)
+==================
+
+* Rebuilt with Cython 3.0.2 to add Python 3.12 support.
+
+
+0.8.1 (2022-11-02)
+==================
+
+* Rebuilt with Cython 3.0.0a11 to add Python 3.11 support.
+
+
+0.8 (2021-10-22)
+================
+
+* Rebuilt with Cython 3.0.0a9 to improve the performance in recent
+  Python 3.x versions.
+
+
+0.7 (2021-10-21)
+================
+
+* Adapted for unsigned thread IDs, as used by Py3.7+.
+  (original patch by Guilherme Dantas)
+
+* Build with Cython 0.29.24 to support Py3.10 and later.
+
+
+0.6 (2021-03-21)
+================
+
+* Rebuild with Cython 0.29.22 to support Py3.9 and later.
+
+
+0.5 (2020-06-05)
+================
+
+* Rebuild with Cython 0.29.20 to support Py3.8 and later.
+
+
+0.4 (2018-08-24)
+================
+
+* Rebuild with Cython 0.28.5.
+
+* Linux wheels are faster through profile guided optimisation.
+
+* Add missing file to sdist.
+  (patch by Mark Harfouche, Github issue #5)
+
+
+0.3 (2017-08-10)
+================
+
+* improve cimport support of C-API
+  (patch by Naotoshi Seo, Github issue #3)
+
+* provide ``fastrlock.__version__``
+
+
+0.2 (2017-08-09)
+================
+
+* add missing readme file to sdist
+
+
+0.1 (2017-06-04)
+================
+
+* initial release

vllm/lib/python3.10/site-packages/fastrlock-0.8.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+fastrlock-0.8.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+fastrlock-0.8.3.dist-info/LICENSE,sha256=edWWCQqdGaUaEXXL0SQGCy8j1Pa-vqeYIkHSMRdRljA,1063
+fastrlock-0.8.3.dist-info/METADATA,sha256=CSkdXG1Tg_Nn1ar1AXfaqMPqOzGI3Er9xl1ed3brFQo,7664
+fastrlock-0.8.3.dist-info/RECORD,,
+fastrlock-0.8.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastrlock-0.8.3.dist-info/WHEEL,sha256=Rk4grMJLqb8wSCjEpvXBqchuGLCY2i_LHup4dkE_8Eo,186
+fastrlock-0.8.3.dist-info/top_level.txt,sha256=QMLNNCjoisR1NTxtzPxl2Zyih9n6sFxd8VCUQzIJHOA,10
+fastrlock/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastrlock/__init__.py,sha256=lYDBBV0R1dtMBmWKorNXKhEma8Fo0OswJJW6zCSGmtU,169
+fastrlock/__pycache__/__init__.cpython-310.pyc,,
+fastrlock/_lock.pxi,sha256=tPIg2qyMZbCZDEXQsp_tb_Em2J0podo3iU3-XEBdnTQ,2608
+fastrlock/rlock.cpython-310-x86_64-linux-gnu.so,sha256=r9XOGqP28vc9-BbAWmWQwb8S04o9hVHuJ9LIgRdymvA,120120
+fastrlock/rlock.pxd,sha256=slrtTC9yStpzsL9FUgoyU69D_YsJAe036GEfH6Z9a0c,313
+fastrlock/rlock.pyx,sha256=YZfaVup-Tkqb42IcNlunf4Vtt2vXVQfZPG4l9BmQlAY,3599

vllm/lib/python3.10/site-packages/fastrlock-0.8.3.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_5_x86_64
+Tag: cp310-cp310-manylinux1_x86_64
+Tag: cp310-cp310-manylinux_2_28_x86_64
+

vllm/lib/python3.10/site-packages/fastrlock-0.8.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastrlock

vllm/lib/python3.10/site-packages/llvmlite/ir/__init__.py

@@ -0,0 +1,11 @@
+"""
+This subpackage implements the LLVM IR classes in pure python
+"""
+
+from .types import *
+from .values import *
+from .module import *
+from .builder import *
+from .instructions import *
+from .transforms import *
+from .context import Context, global_context

vllm/lib/python3.10/site-packages/llvmlite/ir/_utils.py

@@ -0,0 +1,80 @@
+from collections import defaultdict
+
+
+class DuplicatedNameError(NameError):
+    pass
+
+
+class NameScope(object):
+    def __init__(self):
+        self._useset = set([''])
+        self._basenamemap = defaultdict(int)
+
+    def is_used(self, name):
+        return name in self._useset
+
+    def register(self, name, deduplicate=False):
+        if deduplicate:
+            name = self.deduplicate(name)
+        elif self.is_used(name):
+            raise DuplicatedNameError(name)
+        self._useset.add(name)
+        return name
+
+    def deduplicate(self, name):
+        basename = name
+        while self.is_used(name):
+            ident = self._basenamemap[basename] + 1
+            self._basenamemap[basename] = ident
+            name = "{0}.{1}".format(basename, ident)
+        return name
+
+    def get_child(self):
+        return type(self)(parent=self)
+
+
+class _StrCaching(object):
+
+    def _clear_string_cache(self):
+        try:
+            del self.__cached_str
+        except AttributeError:
+            pass
+
+    def __str__(self):
+        try:
+            return self.__cached_str
+        except AttributeError:
+            s = self.__cached_str = self._to_string()
+            return s
+
+
+class _StringReferenceCaching(object):
+
+    def get_reference(self):
+        try:
+            return self.__cached_refstr
+        except AttributeError:
+            s = self.__cached_refstr = self._get_reference()
+            return s
+
+
+class _HasMetadata(object):
+
+    def set_metadata(self, name, node):
+        """
+        Attach unnamed metadata *node* to the metadata slot *name* of this
+        value.
+        """
+        self.metadata[name] = node
+
+    def _stringify_metadata(self, leading_comma=False):
+        if self.metadata:
+            buf = []
+            if leading_comma:
+                buf.append("")
+            buf += ["!{0} {1}".format(k, v.get_reference())
+                    for k, v in self.metadata.items()]
+            return ', '.join(buf)
+        else:
+            return ''

vllm/lib/python3.10/site-packages/llvmlite/ir/builder.py

@@ -0,0 +1,1119 @@
+import contextlib
+import functools
+
+from llvmlite.ir import instructions, types, values
+
+_CMP_MAP = {
+    '>': 'gt',
+    '<': 'lt',
+    '==': 'eq',
+    '!=': 'ne',
+    '>=': 'ge',
+    '<=': 'le',
+}
+
+
+def _unop(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, arg, name='', flags=()):
+            instr = cls(self.block, arg.type, opname, [arg], name, flags)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _binop(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, lhs, rhs, name='', flags=()):
+            if lhs.type != rhs.type:
+                raise ValueError("Operands must be the same type, got (%s, %s)"
+                                 % (lhs.type, rhs.type))
+            instr = cls(self.block, lhs.type, opname, (lhs, rhs), name, flags)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _binop_with_overflow(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, lhs, rhs, name=''):
+            if lhs.type != rhs.type:
+                raise ValueError("Operands must be the same type, got (%s, %s)"
+                                 % (lhs.type, rhs.type))
+            ty = lhs.type
+            if not isinstance(ty, types.IntType):
+                raise TypeError("expected an integer type, got %s" % (ty,))
+            bool_ty = types.IntType(1)
+
+            mod = self.module
+            fnty = types.FunctionType(types.LiteralStructType([ty, bool_ty]),
+                                      [ty, ty])
+            fn = mod.declare_intrinsic("llvm.%s.with.overflow" % (opname,),
+                                       [ty], fnty)
+            ret = self.call(fn, [lhs, rhs], name=name)
+            return ret
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, name=''):
+            instr = cls(self.block, operand.type, opname, [operand], name)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop_intrinsic_int(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, name=''):
+            if not isinstance(operand.type, types.IntType):
+                raise TypeError(
+                    "expected an integer type, got %s" %
+                    operand.type)
+            fn = self.module.declare_intrinsic(opname, [operand.type])
+            return self.call(fn, [operand], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop_intrinsic_float(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, name=''):
+            if not isinstance(
+                    operand.type, (types.FloatType, types.DoubleType)):
+                raise TypeError("expected a float type, got %s" % operand.type)
+            fn = self.module.declare_intrinsic(opname, [operand.type])
+            return self.call(fn, [operand], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop_intrinsic_with_flag(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, flag, name=''):
+            if not isinstance(operand.type, types.IntType):
+                raise TypeError(
+                    "expected an integer type, got %s" %
+                    operand.type)
+            if not (isinstance(flag.type, types.IntType) and
+                    flag.type.width == 1):
+                raise TypeError("expected an i1 type, got %s" % flag.type)
+            fn = self.module.declare_intrinsic(
+                opname, [operand.type, flag.type])
+            return self.call(fn, [operand, flag], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _triop_intrinsic(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, a, b, c, name=''):
+            if a.type != b.type or b.type != c.type:
+                raise TypeError(
+                    "expected types to be the same, got %s, %s, %s" % (
+                        a.type,
+                        b.type,
+                        c.type))
+            elif not isinstance(
+                    a.type,
+                    (types.HalfType, types.FloatType, types.DoubleType)):
+                raise TypeError(
+                    "expected an floating point type, got %s" %
+                    a.type)
+            fn = self.module.declare_intrinsic(opname, [a.type, b.type, c.type])
+            return self.call(fn, [a, b, c], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _castop(opname, cls=instructions.CastInstr):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, val, typ, name=''):
+            if val.type == typ:
+                return val
+            instr = cls(self.block, opname, val, typ, name)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _label_suffix(label, suffix):
+    """Returns (label + suffix) or a truncated version if it's too long.
+    Parameters
+    ----------
+    label : str
+        Label name
+    suffix : str
+        Label suffix
+    """
+    if len(label) > 50:
+        nhead = 25
+        return ''.join([label[:nhead], '..', suffix])
+    else:
+        return label + suffix
+
+
+class IRBuilder(object):
+    def __init__(self, block=None):
+        self._block = block
+        self._anchor = len(block.instructions) if block else 0
+        self.debug_metadata = None
+
+    @property
+    def block(self):
+        """
+        The current basic block.
+        """
+        return self._block
+
+    basic_block = block
+
+    @property
+    def function(self):
+        """
+        The current function.
+        """
+        return self.block.parent
+
+    @property
+    def module(self):
+        """
+        The current module.
+        """
+        return self.block.parent.module
+
+    def position_before(self, instr):
+        """
+        Position immediately before the given instruction.  The current block
+        is also changed to the instruction's basic block.
+        """
+        self._block = instr.parent
+        self._anchor = self._block.instructions.index(instr)
+
+    def position_after(self, instr):
+        """
+        Position immediately after the given instruction.  The current block
+        is also changed to the instruction's basic block.
+        """
+        self._block = instr.parent
+        self._anchor = self._block.instructions.index(instr) + 1
+
+    def position_at_start(self, block):
+        """
+        Position at the start of the basic *block*.
+        """
+        self._block = block
+        self._anchor = 0
+
+    def position_at_end(self, block):
+        """
+        Position at the end of the basic *block*.
+        """
+        self._block = block
+        self._anchor = len(block.instructions)
+
+    def append_basic_block(self, name=''):
+        """
+        Append a basic block, with the given optional *name*, to the current
+        function.  The current block is not changed.  The new block is returned.
+        """
+        return self.function.append_basic_block(name)
+
+    def remove(self, instr):
+        """Remove the given instruction."""
+        idx = self._block.instructions.index(instr)
+        del self._block.instructions[idx]
+        if self._block.terminator == instr:
+            self._block.terminator = None
+        if self._anchor > idx:
+            self._anchor -= 1
+
+    @contextlib.contextmanager
+    def goto_block(self, block):
+        """
+        A context manager which temporarily positions the builder at the end
+        of basic block *bb* (but before any terminator).
+        """
+        old_block = self.basic_block
+        term = block.terminator
+        if term is not None:
+            self.position_before(term)
+        else:
+            self.position_at_end(block)
+        try:
+            yield
+        finally:
+            self.position_at_end(old_block)
+
+    @contextlib.contextmanager
+    def goto_entry_block(self):
+        """
+        A context manager which temporarily positions the builder at the
+        end of the function's entry block.
+        """
+        with self.goto_block(self.function.entry_basic_block):
+            yield
+
+    @contextlib.contextmanager
+    def _branch_helper(self, bbenter, bbexit):
+        self.position_at_end(bbenter)
+        yield bbexit
+        if self.basic_block.terminator is None:
+            self.branch(bbexit)
+
+    @contextlib.contextmanager
+    def if_then(self, pred, likely=None):
+        """
+        A context manager which sets up a conditional basic block based
+        on the given predicate (a i1 value).  If the conditional block
+        is not explicitly terminated, a branch will be added to the next
+        block.
+        If *likely* is given, its boolean value indicates whether the
+        predicate is likely to be true or not, and metadata is issued
+        for LLVM's optimizers to account for that.
+        """
+        bb = self.basic_block
+        bbif = self.append_basic_block(name=_label_suffix(bb.name, '.if'))
+        bbend = self.append_basic_block(name=_label_suffix(bb.name, '.endif'))
+        br = self.cbranch(pred, bbif, bbend)
+        if likely is not None:
+            br.set_weights([99, 1] if likely else [1, 99])
+
+        with self._branch_helper(bbif, bbend):
+            yield bbend
+
+        self.position_at_end(bbend)
+
+    @contextlib.contextmanager
+    def if_else(self, pred, likely=None):
+        """
+        A context manager which sets up two conditional basic blocks based
+        on the given predicate (a i1 value).
+        A tuple of context managers is yield'ed.  Each context manager
+        acts as a if_then() block.
+        *likely* has the same meaning as in if_then().
+
+        Typical use::
+            with builder.if_else(pred) as (then, otherwise):
+                with then:
+                    # emit instructions for when the predicate is true
+                with otherwise:
+                    # emit instructions for when the predicate is false
+        """
+        bb = self.basic_block
+        bbif = self.append_basic_block(name=_label_suffix(bb.name, '.if'))
+        bbelse = self.append_basic_block(name=_label_suffix(bb.name, '.else'))
+        bbend = self.append_basic_block(name=_label_suffix(bb.name, '.endif'))
+        br = self.cbranch(pred, bbif, bbelse)
+        if likely is not None:
+            br.set_weights([99, 1] if likely else [1, 99])
+
+        then = self._branch_helper(bbif, bbend)
+        otherwise = self._branch_helper(bbelse, bbend)
+
+        yield then, otherwise
+
+        self.position_at_end(bbend)
+
+    def _insert(self, instr):
+        if self.debug_metadata is not None and 'dbg' not in instr.metadata:
+            instr.metadata['dbg'] = self.debug_metadata
+        self._block.instructions.insert(self._anchor, instr)
+        self._anchor += 1
+
+    def _set_terminator(self, term):
+        assert not self.block.is_terminated
+        self._insert(term)
+        self.block.terminator = term
+        return term
+
+    #
+    # Arithmetic APIs
+    #
+
+    @_binop('shl')
+    def shl(self, lhs, rhs, name=''):
+        """
+        Left integer shift:
+            name = lhs << rhs
+        """
+
+    @_binop('lshr')
+    def lshr(self, lhs, rhs, name=''):
+        """
+        Logical (unsigned) right integer shift:
+            name = lhs >> rhs
+        """
+
+    @_binop('ashr')
+    def ashr(self, lhs, rhs, name=''):
+        """
+        Arithmetic (signed) right integer shift:
+            name = lhs >> rhs
+        """
+
+    @_binop('add')
+    def add(self, lhs, rhs, name=''):
+        """
+        Integer addition:
+            name = lhs + rhs
+        """
+
+    @_binop('fadd')
+    def fadd(self, lhs, rhs, name=''):
+        """
+        Floating-point addition:
+            name = lhs + rhs
+        """
+
+    @_binop('sub')
+    def sub(self, lhs, rhs, name=''):
+        """
+        Integer subtraction:
+            name = lhs - rhs
+        """
+
+    @_binop('fsub')
+    def fsub(self, lhs, rhs, name=''):
+        """
+        Floating-point subtraction:
+            name = lhs - rhs
+        """
+
+    @_binop('mul')
+    def mul(self, lhs, rhs, name=''):
+        """
+        Integer multiplication:
+            name = lhs * rhs
+        """
+
+    @_binop('fmul')
+    def fmul(self, lhs, rhs, name=''):
+        """
+        Floating-point multiplication:
+            name = lhs * rhs
+        """
+
+    @_binop('udiv')
+    def udiv(self, lhs, rhs, name=''):
+        """
+        Unsigned integer division:
+            name = lhs / rhs
+        """
+
+    @_binop('sdiv')
+    def sdiv(self, lhs, rhs, name=''):
+        """
+        Signed integer division:
+            name = lhs / rhs
+        """
+
+    @_binop('fdiv')
+    def fdiv(self, lhs, rhs, name=''):
+        """
+        Floating-point division:
+            name = lhs / rhs
+        """
+
+    @_binop('urem')
+    def urem(self, lhs, rhs, name=''):
+        """
+        Unsigned integer remainder:
+            name = lhs % rhs
+        """
+
+    @_binop('srem')
+    def srem(self, lhs, rhs, name=''):
+        """
+        Signed integer remainder:
+            name = lhs % rhs
+        """
+
+    @_binop('frem')
+    def frem(self, lhs, rhs, name=''):
+        """
+        Floating-point remainder:
+            name = lhs % rhs
+        """
+
+    @_binop('or')
+    def or_(self, lhs, rhs, name=''):
+        """
+        Bitwise integer OR:
+            name = lhs | rhs
+        """
+
+    @_binop('and')
+    def and_(self, lhs, rhs, name=''):
+        """
+        Bitwise integer AND:
+            name = lhs & rhs
+        """
+
+    @_binop('xor')
+    def xor(self, lhs, rhs, name=''):
+        """
+        Bitwise integer XOR:
+            name = lhs ^ rhs
+        """
+
+    @_binop_with_overflow('sadd')
+    def sadd_with_overflow(self, lhs, rhs, name=''):
+        """
+        Signed integer addition with overflow:
+            name = {result, overflow bit} = lhs + rhs
+        """
+
+    @_binop_with_overflow('smul')
+    def smul_with_overflow(self, lhs, rhs, name=''):
+        """
+        Signed integer multiplication with overflow:
+            name = {result, overflow bit} = lhs * rhs
+        """
+
+    @_binop_with_overflow('ssub')
+    def ssub_with_overflow(self, lhs, rhs, name=''):
+        """
+        Signed integer subtraction with overflow:
+            name = {result, overflow bit} = lhs - rhs
+        """
+
+    @_binop_with_overflow('uadd')
+    def uadd_with_overflow(self, lhs, rhs, name=''):
+        """
+        Unsigned integer addition with overflow:
+            name = {result, overflow bit} = lhs + rhs
+        """
+
+    @_binop_with_overflow('umul')
+    def umul_with_overflow(self, lhs, rhs, name=''):
+        """
+        Unsigned integer multiplication with overflow:
+            name = {result, overflow bit} = lhs * rhs
+        """
+
+    @_binop_with_overflow('usub')
+    def usub_with_overflow(self, lhs, rhs, name=''):
+        """
+        Unsigned integer subtraction with overflow:
+            name = {result, overflow bit} = lhs - rhs
+        """
+
+    #
+    # Unary APIs
+    #
+
+    def not_(self, value, name=''):
+        """
+        Bitwise integer complement:
+            name = ~value
+        """
+        if isinstance(value.type, types.VectorType):
+            rhs = values.Constant(value.type, (-1,) * value.type.count)
+        else:
+            rhs = values.Constant(value.type, -1)
+        return self.xor(value, rhs, name=name)
+
+    def neg(self, value, name=''):
+        """
+        Integer negative:
+            name = -value
+        """
+        return self.sub(values.Constant(value.type, 0), value, name=name)
+
+    @_unop('fneg')
+    def fneg(self, arg, name='', flags=()):
+        """
+        Floating-point negative:
+            name = -arg
+        """
+
+    #
+    # Comparison APIs
+    #
+
+    def _icmp(self, prefix, cmpop, lhs, rhs, name):
+        try:
+            op = _CMP_MAP[cmpop]
+        except KeyError:
+            raise ValueError("invalid comparison %r for icmp" % (cmpop,))
+        if cmpop not in ('==', '!='):
+            op = prefix + op
+        instr = instructions.ICMPInstr(self.block, op, lhs, rhs, name=name)
+        self._insert(instr)
+        return instr
+
+    def icmp_signed(self, cmpop, lhs, rhs, name=''):
+        """
+        Signed integer comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._icmp('s', cmpop, lhs, rhs, name)
+
+    def icmp_unsigned(self, cmpop, lhs, rhs, name=''):
+        """
+        Unsigned integer (or pointer) comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._icmp('u', cmpop, lhs, rhs, name)
+
+    def fcmp_ordered(self, cmpop, lhs, rhs, name='', flags=()):
+        """
+        Floating-point ordered comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        if cmpop in _CMP_MAP:
+            op = 'o' + _CMP_MAP[cmpop]
+        else:
+            op = cmpop
+        instr = instructions.FCMPInstr(
+            self.block, op, lhs, rhs, name=name, flags=flags)
+        self._insert(instr)
+        return instr
+
+    def fcmp_unordered(self, cmpop, lhs, rhs, name='', flags=()):
+        """
+        Floating-point unordered comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        if cmpop in _CMP_MAP:
+            op = 'u' + _CMP_MAP[cmpop]
+        else:
+            op = cmpop
+        instr = instructions.FCMPInstr(
+            self.block, op, lhs, rhs, name=name, flags=flags)
+        self._insert(instr)
+        return instr
+
+    def select(self, cond, lhs, rhs, name='', flags=()):
+        """
+        Ternary select operator:
+            name = cond ? lhs : rhs
+        """
+        instr = instructions.SelectInstr(self.block, cond, lhs, rhs, name=name,
+                                         flags=flags)
+        self._insert(instr)
+        return instr
+
+    #
+    # Cast APIs
+    #
+
+    @_castop('trunc')
+    def trunc(self, value, typ, name=''):
+        """
+        Truncating integer downcast to a smaller type:
+            name = (typ) value
+        """
+
+    @_castop('zext')
+    def zext(self, value, typ, name=''):
+        """
+        Zero-extending integer upcast to a larger type:
+            name = (typ) value
+        """
+
+    @_castop('sext')
+    def sext(self, value, typ, name=''):
+        """
+        Sign-extending integer upcast to a larger type:
+            name = (typ) value
+        """
+
+    @_castop('fptrunc')
+    def fptrunc(self, value, typ, name=''):
+        """
+        Floating-point downcast to a less precise type:
+            name = (typ) value
+        """
+
+    @_castop('fpext')
+    def fpext(self, value, typ, name=''):
+        """
+        Floating-point upcast to a more precise type:
+            name = (typ) value
+        """
+
+    @_castop('bitcast')
+    def bitcast(self, value, typ, name=''):
+        """
+        Pointer cast to a different pointer type:
+            name = (typ) value
+        """
+
+    @_castop('addrspacecast')
+    def addrspacecast(self, value, typ, name=''):
+        """
+        Pointer cast to a different address space:
+            name = (typ) value
+        """
+
+    @_castop('fptoui')
+    def fptoui(self, value, typ, name=''):
+        """
+        Convert floating-point to unsigned integer:
+            name = (typ) value
+        """
+
+    @_castop('uitofp')
+    def uitofp(self, value, typ, name=''):
+        """
+        Convert unsigned integer to floating-point:
+            name = (typ) value
+        """
+
+    @_castop('fptosi')
+    def fptosi(self, value, typ, name=''):
+        """
+        Convert floating-point to signed integer:
+            name = (typ) value
+        """
+
+    @_castop('sitofp')
+    def sitofp(self, value, typ, name=''):
+        """
+        Convert signed integer to floating-point:
+            name = (typ) value
+        """
+
+    @_castop('ptrtoint')
+    def ptrtoint(self, value, typ, name=''):
+        """
+        Cast pointer to integer:
+            name = (typ) value
+        """
+
+    @_castop('inttoptr')
+    def inttoptr(self, value, typ, name=''):
+        """
+        Cast integer to pointer:
+            name = (typ) value
+        """
+
+    #
+    # Memory APIs
+    #
+
+    def alloca(self, typ, size=None, name=''):
+        """
+        Stack-allocate a slot for *size* elements of the given type.
+        (default one element)
+        """
+        if size is None:
+            pass
+        elif isinstance(size, (values.Value, values.Constant)):
+            assert isinstance(size.type, types.IntType)
+        else:
+            # If it is not a Value instance,
+            # assume to be a Python integer.
+            size = values.Constant(types.IntType(32), size)
+
+        al = instructions.AllocaInstr(self.block, typ, size, name)
+        self._insert(al)
+        return al
+
+    def load(self, ptr, name='', align=None):
+        """
+        Load value from pointer, with optional guaranteed alignment:
+            name = *ptr
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot load from value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        ld = instructions.LoadInstr(self.block, ptr, name)
+        ld.align = align
+        self._insert(ld)
+        return ld
+
+    def store(self, value, ptr, align=None):
+        """
+        Store value to pointer, with optional guaranteed alignment:
+            *ptr = name
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot store to value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        if ptr.type.pointee != value.type:
+            raise TypeError("cannot store %s to %s: mismatching types"
+                            % (value.type, ptr.type))
+        st = instructions.StoreInstr(self.block, value, ptr)
+        st.align = align
+        self._insert(st)
+        return st
+
+    def load_atomic(self, ptr, ordering, align, name=''):
+        """
+        Load value from pointer, with optional guaranteed alignment:
+            name = *ptr
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot load from value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        ld = instructions.LoadAtomicInstr(
+            self.block, ptr, ordering, align, name)
+        self._insert(ld)
+        return ld
+
+    def store_atomic(self, value, ptr, ordering, align):
+        """
+        Store value to pointer, with optional guaranteed alignment:
+            *ptr = name
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot store to value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        if ptr.type.pointee != value.type:
+            raise TypeError("cannot store %s to %s: mismatching types"
+                            % (value.type, ptr.type))
+        st = instructions.StoreAtomicInstr(
+            self.block, value, ptr, ordering, align)
+        self._insert(st)
+        return st
+
+    #
+    # Terminators APIs
+    #
+
+    def switch(self, value, default):
+        """
+        Create a switch-case with a single *default* target.
+        """
+        swt = instructions.SwitchInstr(self.block, 'switch', value, default)
+        self._set_terminator(swt)
+        return swt
+
+    def branch(self, target):
+        """
+        Unconditional branch to *target*.
+        """
+        br = instructions.Branch(self.block, "br", [target])
+        self._set_terminator(br)
+        return br
+
+    def cbranch(self, cond, truebr, falsebr):
+        """
+        Conditional branch to *truebr* if *cond* is true, else to *falsebr*.
+        """
+        br = instructions.ConditionalBranch(self.block, "br",
+                                            [cond, truebr, falsebr])
+        self._set_terminator(br)
+        return br
+
+    def branch_indirect(self, addr):
+        """
+        Indirect branch to target *addr*.
+        """
+        br = instructions.IndirectBranch(self.block, "indirectbr", addr)
+        self._set_terminator(br)
+        return br
+
+    def ret_void(self):
+        """
+        Return from function without a value.
+        """
+        return self._set_terminator(
+            instructions.Ret(self.block, "ret void"))
+
+    def ret(self, value):
+        """
+        Return from function with the given *value*.
+        """
+        return self._set_terminator(
+            instructions.Ret(self.block, "ret", value))
+
+    def resume(self, landingpad):
+        """
+        Resume an in-flight exception.
+        """
+        br = instructions.Branch(self.block, "resume", [landingpad])
+        self._set_terminator(br)
+        return br
+
+    # Call APIs
+
+    def call(self, fn, args, name='', cconv=None, tail=False, fastmath=(),
+             attrs=(), arg_attrs=None):
+        """
+        Call function *fn* with *args*:
+            name = fn(args...)
+        """
+        inst = instructions.CallInstr(self.block, fn, args, name=name,
+                                      cconv=cconv, tail=tail, fastmath=fastmath,
+                                      attrs=attrs, arg_attrs=arg_attrs)
+        self._insert(inst)
+        return inst
+
+    def asm(self, ftype, asm, constraint, args, side_effect, name=''):
+        """
+        Inline assembler.
+        """
+        asm = instructions.InlineAsm(ftype, asm, constraint, side_effect)
+        return self.call(asm, args, name)
+
+    def load_reg(self, reg_type, reg_name, name=''):
+        """
+        Load a register value into an LLVM value.
+          Example: v = load_reg(IntType(32), "eax")
+        """
+        ftype = types.FunctionType(reg_type, [])
+        return self.asm(ftype, "", "={%s}" % reg_name, [], False, name)
+
+    def store_reg(self, value, reg_type, reg_name, name=''):
+        """
+        Store an LLVM value inside a register
+        Example:
+          store_reg(Constant(IntType(32), 0xAAAAAAAA), IntType(32), "eax")
+        """
+        ftype = types.FunctionType(types.VoidType(), [reg_type])
+        return self.asm(ftype, "", "{%s}" % reg_name, [value], True, name)
+
+    def invoke(self, fn, args, normal_to, unwind_to,
+               name='', cconv=None, fastmath=(), attrs=(), arg_attrs=None):
+        inst = instructions.InvokeInstr(self.block, fn, args, normal_to,
+                                        unwind_to, name=name, cconv=cconv,
+                                        fastmath=fastmath, attrs=attrs,
+                                        arg_attrs=arg_attrs)
+        self._set_terminator(inst)
+        return inst
+
+    # GEP APIs
+
+    def gep(self, ptr, indices, inbounds=False, name=''):
+        """
+        Compute effective address (getelementptr):
+            name = getelementptr ptr, <indices...>
+        """
+        instr = instructions.GEPInstr(self.block, ptr, indices,
+                                      inbounds=inbounds, name=name)
+        self._insert(instr)
+        return instr
+
+    # Vector Operations APIs
+
+    def extract_element(self, vector, idx, name=''):
+        """
+        Returns the value at position idx.
+        """
+        instr = instructions.ExtractElement(self.block, vector, idx, name=name)
+        self._insert(instr)
+        return instr
+
+    def insert_element(self, vector, value, idx, name=''):
+        """
+        Returns vector with vector[idx] replaced by value.
+        The result is undefined if the idx is larger or equal the vector length.
+        """
+        instr = instructions.InsertElement(self.block, vector, value, idx,
+                                           name=name)
+        self._insert(instr)
+        return instr
+
+    def shuffle_vector(self, vector1, vector2, mask, name=''):
+        """
+        Constructs a permutation of elements from *vector1* and *vector2*.
+        Returns a new vector in the same length of *mask*.
+
+        * *vector1* and *vector2* must have the same element type.
+        * *mask* must be a constant vector of integer types.
+        """
+        instr = instructions.ShuffleVector(self.block, vector1, vector2, mask,
+                                           name=name)
+        self._insert(instr)
+        return instr
+
+    # Aggregate APIs
+
+    def extract_value(self, agg, idx, name=''):
+        """
+        Extract member number *idx* from aggregate.
+        """
+        if not isinstance(idx, (tuple, list)):
+            idx = [idx]
+        instr = instructions.ExtractValue(self.block, agg, idx, name=name)
+        self._insert(instr)
+        return instr
+
+    def insert_value(self, agg, value, idx, name=''):
+        """
+        Insert *value* into member number *idx* from aggregate.
+        """
+        if not isinstance(idx, (tuple, list)):
+            idx = [idx]
+        instr = instructions.InsertValue(self.block, agg, value, idx, name=name)
+        self._insert(instr)
+        return instr
+
+    # PHI APIs
+
+    def phi(self, typ, name='', flags=()):
+        inst = instructions.PhiInstr(self.block, typ, name=name, flags=flags)
+        self._insert(inst)
+        return inst
+
+    # Special API
+
+    def unreachable(self):
+        inst = instructions.Unreachable(self.block)
+        self._set_terminator(inst)
+        return inst
+
+    def atomic_rmw(self, op, ptr, val, ordering, name=''):
+        inst = instructions.AtomicRMW(
+            self.block, op, ptr, val, ordering, name=name)
+        self._insert(inst)
+        return inst
+
+    def cmpxchg(self, ptr, cmp, val, ordering, failordering=None, name=''):
+        """
+        Atomic compared-and-set:
+            atomic {
+                old = *ptr
+                success = (old == cmp)
+                if (success)
+                    *ptr = val
+                }
+            name = { old, success }
+
+        If failordering is `None`, the value of `ordering` is used.
+        """
+        failordering = ordering if failordering is None else failordering
+        inst = instructions.CmpXchg(self.block, ptr, cmp, val, ordering,
+                                    failordering, name=name)
+        self._insert(inst)
+        return inst
+
+    def landingpad(self, typ, name='', cleanup=False):
+        inst = instructions.LandingPadInstr(self.block, typ, name, cleanup)
+        self._insert(inst)
+        return inst
+
+    def assume(self, cond):
+        """
+        Optimizer hint: assume *cond* is always true.
+        """
+        fn = self.module.declare_intrinsic("llvm.assume")
+        return self.call(fn, [cond])
+
+    def fence(self, ordering, targetscope=None, name=''):
+        """
+        Add a memory barrier, preventing certain reorderings of load and/or
+        store accesses with
+        respect to other processors and devices.
+        """
+        inst = instructions.Fence(self.block, ordering, targetscope, name=name)
+        self._insert(inst)
+        return inst
+
+    def comment(self, text):
+        """
+        Puts a single-line comment into the generated IR. This will be ignored
+        by LLVM, but can be useful for debugging the output of a compiler. Adds
+        a comment to the source file.
+
+        * *text* is a string that does not contain new line characters.
+        """
+        inst = instructions.Comment(self.block, text)
+        self._insert(inst)
+        return inst
+
+    @_uniop_intrinsic_int("llvm.bswap")
+    def bswap(self, cond):
+        """
+        Used to byte swap integer values with an even number of bytes (positive
+        multiple of 16 bits)
+        """
+
+    @_uniop_intrinsic_int("llvm.bitreverse")
+    def bitreverse(self, cond):
+        """
+        Reverse the bitpattern of an integer value; for example 0b10110110
+        becomes 0b01101101.
+        """
+
+    @_uniop_intrinsic_int("llvm.ctpop")
+    def ctpop(self, cond):
+        """
+        Counts the number of bits set in a value.
+        """
+
+    @_uniop_intrinsic_with_flag("llvm.ctlz")
+    def ctlz(self, cond, flag):
+        """
+        Counts leading zero bits in *value*. Boolean *flag* indicates whether
+        the result is defined for ``0``.
+        """
+
+    @_uniop_intrinsic_with_flag("llvm.cttz")
+    def cttz(self, cond, flag):
+        """
+        Counts trailing zero bits in *value*. Boolean *flag* indicates whether
+        the result is defined for ``0``.
+        """
+
+    @_triop_intrinsic("llvm.fma")
+    def fma(self, a, b, c):
+        """
+        Perform the fused multiply-add operation.
+        """
+
+    def convert_from_fp16(self, a, to=None, name=''):
+        """
+        Convert from an i16 to the given FP type
+        """
+        if not to:
+            raise TypeError("expected a float return type")
+        if not isinstance(to, (types.FloatType, types.DoubleType)):
+            raise TypeError("expected a float type, got %s" % to)
+        if not (isinstance(a.type, types.IntType) and a.type.width == 16):
+            raise TypeError("expected an i16 type, got %s" % a.type)
+
+        opname = 'llvm.convert.from.fp16'
+        fn = self.module.declare_intrinsic(opname, [to])
+        return self.call(fn, [a], name)
+
+    @_uniop_intrinsic_float("llvm.convert.to.fp16")
+    def convert_to_fp16(self, a):
+        """
+        Convert the given FP number to an i16
+        """

vllm/lib/python3.10/site-packages/llvmlite/ir/context.py

@@ -0,0 +1,20 @@
+from llvmlite.ir import _utils
+from llvmlite.ir import types
+
+
+class Context(object):
+    def __init__(self):
+        self.scope = _utils.NameScope()
+        self.identified_types = {}
+
+    def get_identified_type(self, name):
+        if name not in self.identified_types:
+            self.scope.register(name)
+            ty = types.IdentifiedStructType(self, name)
+            self.identified_types[name] = ty
+        else:
+            ty = self.identified_types[name]
+        return ty
+
+
+global_context = Context()

vllm/lib/python3.10/site-packages/llvmlite/ir/instructions.py

@@ -0,0 +1,893 @@
+"""
+Implementation of LLVM IR instructions.
+"""
+
+from llvmlite.ir import types
+from llvmlite.ir.values import (Block, Function, Value, NamedValue, Constant,
+                                MetaDataArgument, MetaDataString, AttributeSet,
+                                Undefined, ArgumentAttributes)
+from llvmlite.ir._utils import _HasMetadata
+
+
+class Instruction(NamedValue, _HasMetadata):
+    def __init__(self, parent, typ, opname, operands, name='', flags=()):
+        super(Instruction, self).__init__(parent, typ, name=name)
+        assert isinstance(parent, Block)
+        assert isinstance(flags, (tuple, list))
+        self.opname = opname
+        self.operands = operands
+        self.flags = list(flags)
+        self.metadata = {}
+
+    @property
+    def function(self):
+        return self.parent.function
+
+    @property
+    def module(self):
+        return self.parent.function.module
+
+    def descr(self, buf):
+        opname = self.opname
+        if self.flags:
+            opname = ' '.join([opname] + self.flags)
+        operands = ', '.join([op.get_reference() for op in self.operands])
+        typ = self.type
+        metadata = self._stringify_metadata(leading_comma=True)
+        buf.append("{0} {1} {2}{3}\n"
+                   .format(opname, typ, operands, metadata))
+
+    def replace_usage(self, old, new):
+        if old in self.operands:
+            ops = []
+            for op in self.operands:
+                ops.append(new if op is old else op)
+            self.operands = tuple(ops)
+            self._clear_string_cache()
+
+    def __repr__(self):
+        return "<ir.%s %r of type '%s', opname %r, operands %r>" % (
+            self.__class__.__name__, self.name, self.type,
+            self.opname, self.operands)
+
+
+class CallInstrAttributes(AttributeSet):
+    _known = frozenset(['convergent', 'noreturn', 'nounwind', 'readonly',
+                        'readnone', 'noinline', 'alwaysinline'])
+
+
+TailMarkerOptions = frozenset(['tail', 'musttail', 'notail'])
+
+
+class FastMathFlags(AttributeSet):
+    _known = frozenset(['fast', 'nnan', 'ninf', 'nsz', 'arcp', 'contract',
+                        'afn', 'reassoc'])
+
+
+class CallInstr(Instruction):
+    def __init__(self, parent, func, args, name='', cconv=None, tail=None,
+                 fastmath=(), attrs=(), arg_attrs=None):
+        self.cconv = (func.calling_convention
+                      if cconv is None and isinstance(func, Function)
+                      else cconv)
+
+        # For backwards compatibility with previous API of accepting a "truthy"
+        # value for a hint to the optimizer to potentially tail optimize.
+        if isinstance(tail, str) and tail in TailMarkerOptions:
+            pass
+        elif tail:
+            tail = "tail"
+        else:
+            tail = ""
+
+        self.tail = tail
+        self.fastmath = FastMathFlags(fastmath)
+        self.attributes = CallInstrAttributes(attrs)
+        self.arg_attributes = {}
+        if arg_attrs:
+            for idx, attrs in arg_attrs.items():
+                if not (0 <= idx < len(args)):
+                    raise ValueError("Invalid argument index {}"
+                                     .format(idx))
+                self.arg_attributes[idx] = ArgumentAttributes(attrs)
+
+        # Fix and validate arguments
+        args = list(args)
+        for i in range(len(func.function_type.args)):
+            arg = args[i]
+            expected_type = func.function_type.args[i]
+            if (isinstance(expected_type, types.MetaDataType) and
+                    arg.type != expected_type):
+                arg = MetaDataArgument(arg)
+            if arg.type != expected_type:
+                msg = ("Type of #{0} arg mismatch: {1} != {2}"
+                       .format(1 + i, expected_type, arg.type))
+                raise TypeError(msg)
+            args[i] = arg
+
+        super(CallInstr, self).__init__(parent, func.function_type.return_type,
+                                        "call", [func] + list(args), name=name)
+
+    @property
+    def callee(self):
+        return self.operands[0]
+
+    @callee.setter
+    def callee(self, newcallee):
+        self.operands[0] = newcallee
+
+    @property
+    def args(self):
+        return self.operands[1:]
+
+    def replace_callee(self, newfunc):
+        if newfunc.function_type != self.callee.function_type:
+            raise TypeError("New function has incompatible type")
+        self.callee = newfunc
+
+    @property
+    def called_function(self):
+        """The callee function"""
+        return self.callee
+
+    def _descr(self, buf, add_metadata):
+        def descr_arg(i, a):
+            if i in self.arg_attributes:
+                attrs = ' '.join(self.arg_attributes[i]._to_list(a.type)) + ' '
+            else:
+                attrs = ''
+            return '{0} {1}{2}'.format(a.type, attrs, a.get_reference())
+        args = ', '.join([descr_arg(i, a) for i, a in enumerate(self.args)])
+
+        fnty = self.callee.function_type
+        # Only print function type if variable-argument
+        if fnty.var_arg:
+            ty = fnty
+        # Otherwise, just print the return type.
+        else:
+            # Fastmath flag work only in this case
+            ty = fnty.return_type
+        callee_ref = "{0} {1}".format(ty, self.callee.get_reference())
+        if self.cconv:
+            callee_ref = "{0} {1}".format(self.cconv, callee_ref)
+
+        tail_marker = ""
+        if self.tail:
+            tail_marker = "{0} ".format(self.tail)
+
+        fn_attrs = ' ' + ' '.join(self.attributes._to_list(fnty.return_type))\
+            if self.attributes else ''
+
+        fm_attrs = ' ' + ' '.join(self.fastmath._to_list(fnty.return_type))\
+            if self.fastmath else ''
+
+        buf.append("{tail}{op}{fastmath} {callee}({args}){attr}{meta}\n".format(
+            tail=tail_marker,
+            op=self.opname,
+            callee=callee_ref,
+            fastmath=fm_attrs,
+            args=args,
+            attr=fn_attrs,
+            meta=(self._stringify_metadata(leading_comma=True)
+                  if add_metadata else ""),
+        ))
+
+    def descr(self, buf):
+        self._descr(buf, add_metadata=True)
+
+
+class InvokeInstr(CallInstr):
+    def __init__(self, parent, func, args, normal_to, unwind_to, name='',
+                 cconv=None, fastmath=(), attrs=(), arg_attrs=None):
+        assert isinstance(normal_to, Block)
+        assert isinstance(unwind_to, Block)
+        super(InvokeInstr, self).__init__(parent, func, args, name, cconv,
+                                          tail=False, fastmath=fastmath,
+                                          attrs=attrs, arg_attrs=arg_attrs)
+        self.opname = "invoke"
+        self.normal_to = normal_to
+        self.unwind_to = unwind_to
+
+    def descr(self, buf):
+        super(InvokeInstr, self)._descr(buf, add_metadata=False)
+        buf.append("      to label {0} unwind label {1}{metadata}\n".format(
+            self.normal_to.get_reference(),
+            self.unwind_to.get_reference(),
+            metadata=self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class Terminator(Instruction):
+    def __init__(self, parent, opname, operands):
+        super(Terminator, self).__init__(parent, types.VoidType(), opname,
+                                         operands)
+
+    def descr(self, buf):
+        opname = self.opname
+        operands = ', '.join(["{0} {1}".format(op.type, op.get_reference())
+                              for op in self.operands])
+        metadata = self._stringify_metadata(leading_comma=True)
+        buf.append("{0} {1}{2}".format(opname, operands, metadata))
+
+
+class PredictableInstr(Instruction):
+
+    def set_weights(self, weights):
+        operands = [MetaDataString(self.module, "branch_weights")]
+        for w in weights:
+            if w < 0:
+                raise ValueError("branch weight must be a positive integer")
+            operands.append(Constant(types.IntType(32), w))
+        md = self.module.add_metadata(operands)
+        self.set_metadata("prof", md)
+
+
+class Ret(Terminator):
+    def __init__(self, parent, opname, return_value=None):
+        operands = [return_value] if return_value is not None else []
+        super(Ret, self).__init__(parent, opname, operands)
+
+    @property
+    def return_value(self):
+        if self.operands:
+            return self.operands[0]
+        else:
+            return None
+
+    def descr(self, buf):
+        return_value = self.return_value
+        metadata = self._stringify_metadata(leading_comma=True)
+        if return_value is not None:
+            buf.append("{0} {1} {2}{3}\n"
+                       .format(self.opname, return_value.type,
+                               return_value.get_reference(),
+                               metadata))
+        else:
+            buf.append("{0}{1}\n".format(self.opname, metadata))
+
+
+class Branch(Terminator):
+    pass
+
+
+class ConditionalBranch(PredictableInstr, Terminator):
+    pass
+
+
+class IndirectBranch(PredictableInstr, Terminator):
+    def __init__(self, parent, opname, addr):
+        super(IndirectBranch, self).__init__(parent, opname, [addr])
+        self.destinations = []
+
+    @property
+    def address(self):
+        return self.operands[0]
+
+    def add_destination(self, block):
+        assert isinstance(block, Block)
+        self.destinations.append(block)
+
+    def descr(self, buf):
+        destinations = ["label {0}".format(blk.get_reference())
+                        for blk in self.destinations]
+        buf.append("indirectbr {0} {1}, [{2}]  {3}\n".format(
+            self.address.type,
+            self.address.get_reference(),
+            ', '.join(destinations),
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class SwitchInstr(PredictableInstr, Terminator):
+
+    def __init__(self, parent, opname, val, default):
+        super(SwitchInstr, self).__init__(parent, opname, [val])
+        self.default = default
+        self.cases = []
+
+    @property
+    def value(self):
+        return self.operands[0]
+
+    def add_case(self, val, block):
+        assert isinstance(block, Block)
+        if not isinstance(val, Value):
+            val = Constant(self.value.type, val)
+        self.cases.append((val, block))
+
+    def descr(self, buf):
+        cases = ["{0} {1}, label {2}".format(val.type, val.get_reference(),
+                                             blk.get_reference())
+                 for val, blk in self.cases]
+        buf.append("switch {0} {1}, label {2} [{3}]  {4}\n".format(
+            self.value.type,
+            self.value.get_reference(),
+            self.default.get_reference(),
+            ' '.join(cases),
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class Resume(Terminator):
+    pass
+
+
+class SelectInstr(Instruction):
+    def __init__(self, parent, cond, lhs, rhs, name='', flags=()):
+        assert lhs.type == rhs.type
+        super(SelectInstr, self).__init__(parent, lhs.type, "select",
+                                          [cond, lhs, rhs], name=name,
+                                          flags=flags)
+
+    @property
+    def cond(self):
+        return self.operands[0]
+
+    @property
+    def lhs(self):
+        return self.operands[1]
+
+    @property
+    def rhs(self):
+        return self.operands[2]
+
+    def descr(self, buf):
+        buf.append("select {0} {1} {2}, {3} {4}, {5} {6} {7}\n".format(
+            ' '.join(self.flags),
+            self.cond.type, self.cond.get_reference(),
+            self.lhs.type, self.lhs.get_reference(),
+            self.rhs.type, self.rhs.get_reference(),
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class CompareInstr(Instruction):
+    # Define the following in subclasses
+    OPNAME = 'invalid-compare'
+    VALID_OP = {}
+
+    def __init__(self, parent, op, lhs, rhs, name='', flags=[]):
+        if op not in self.VALID_OP:
+            raise ValueError("invalid comparison %r for %s" % (op, self.OPNAME))
+        for flag in flags:
+            if flag not in self.VALID_FLAG:
+                raise ValueError("invalid flag %r for %s" % (flag, self.OPNAME))
+        opname = self.OPNAME
+        if isinstance(lhs.type, types.VectorType):
+            typ = types.VectorType(types.IntType(1), lhs.type.count)
+        else:
+            typ = types.IntType(1)
+        super(CompareInstr, self).__init__(parent, typ,
+                                           opname, [lhs, rhs], flags=flags,
+                                           name=name)
+        self.op = op
+
+    def descr(self, buf):
+        buf.append("{opname}{flags} {op} {ty} {lhs}, {rhs} {meta}\n".format(
+            opname=self.opname,
+            flags=''.join(' ' + it for it in self.flags),
+            op=self.op,
+            ty=self.operands[0].type,
+            lhs=self.operands[0].get_reference(),
+            rhs=self.operands[1].get_reference(),
+            meta=self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class ICMPInstr(CompareInstr):
+    OPNAME = 'icmp'
+    VALID_OP = {
+        'eq': 'equal',
+        'ne': 'not equal',
+        'ugt': 'unsigned greater than',
+        'uge': 'unsigned greater or equal',
+        'ult': 'unsigned less than',
+        'ule': 'unsigned less or equal',
+        'sgt': 'signed greater than',
+        'sge': 'signed greater or equal',
+        'slt': 'signed less than',
+        'sle': 'signed less or equal',
+    }
+    VALID_FLAG = set()
+
+
+class FCMPInstr(CompareInstr):
+    OPNAME = 'fcmp'
+    VALID_OP = {
+        'false': 'no comparison, always returns false',
+        'oeq': 'ordered and equal',
+        'ogt': 'ordered and greater than',
+        'oge': 'ordered and greater than or equal',
+        'olt': 'ordered and less than',
+        'ole': 'ordered and less than or equal',
+        'one': 'ordered and not equal',
+        'ord': 'ordered (no nans)',
+        'ueq': 'unordered or equal',
+        'ugt': 'unordered or greater than',
+        'uge': 'unordered or greater than or equal',
+        'ult': 'unordered or less than',
+        'ule': 'unordered or less than or equal',
+        'une': 'unordered or not equal',
+        'uno': 'unordered (either nans)',
+        'true': 'no comparison, always returns true',
+    }
+    VALID_FLAG = {'nnan', 'ninf', 'nsz', 'arcp', 'contract', 'afn', 'reassoc',
+                  'fast'}
+
+
+class CastInstr(Instruction):
+    def __init__(self, parent, op, val, typ, name=''):
+        super(CastInstr, self).__init__(parent, typ, op, [val], name=name)
+
+    def descr(self, buf):
+        buf.append("{0} {1} {2} to {3} {4}\n".format(
+            self.opname,
+            self.operands[0].type,
+            self.operands[0].get_reference(),
+            self.type,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class LoadInstr(Instruction):
+
+    def __init__(self, parent, ptr, name=''):
+        super(LoadInstr, self).__init__(parent, ptr.type.pointee, "load",
+                                        [ptr], name=name)
+        self.align = None
+
+    def descr(self, buf):
+        [val] = self.operands
+        if self.align is not None:
+            align = ', align %d' % (self.align)
+        else:
+            align = ''
+        buf.append("load {0}, {1} {2}{3}{4}\n".format(
+            val.type.pointee,
+            val.type,
+            val.get_reference(),
+            align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class StoreInstr(Instruction):
+    def __init__(self, parent, val, ptr):
+        super(StoreInstr, self).__init__(parent, types.VoidType(), "store",
+                                         [val, ptr])
+
+    def descr(self, buf):
+        val, ptr = self.operands
+        if self.align is not None:
+            align = ', align %d' % (self.align)
+        else:
+            align = ''
+        buf.append("store {0} {1}, {2} {3}{4}{5}\n".format(
+            val.type,
+            val.get_reference(),
+            ptr.type,
+            ptr.get_reference(),
+            align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class LoadAtomicInstr(Instruction):
+    def __init__(self, parent, ptr, ordering, align, name=''):
+        super(LoadAtomicInstr, self).__init__(parent, ptr.type.pointee,
+                                              "load atomic", [ptr], name=name)
+        self.ordering = ordering
+        self.align = align
+
+    def descr(self, buf):
+        [val] = self.operands
+        buf.append("load atomic {0}, {1} {2} {3}, align {4}{5}\n".format(
+            val.type.pointee,
+            val.type,
+            val.get_reference(),
+            self.ordering,
+            self.align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class StoreAtomicInstr(Instruction):
+    def __init__(self, parent, val, ptr, ordering, align):
+        super(StoreAtomicInstr, self).__init__(parent, types.VoidType(),
+                                               "store atomic", [val, ptr])
+        self.ordering = ordering
+        self.align = align
+
+    def descr(self, buf):
+        val, ptr = self.operands
+        buf.append("store atomic {0} {1}, {2} {3} {4}, align {5}{6}\n".format(
+            val.type,
+            val.get_reference(),
+            ptr.type,
+            ptr.get_reference(),
+            self.ordering,
+            self.align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class AllocaInstr(Instruction):
+    def __init__(self, parent, typ, count, name):
+        operands = [count] if count else ()
+        super(AllocaInstr, self).__init__(parent, typ.as_pointer(), "alloca",
+                                          operands, name)
+        self.align = None
+
+    def descr(self, buf):
+        buf.append("{0} {1}".format(self.opname, self.type.pointee))
+        if self.operands:
+            op, = self.operands
+            buf.append(", {0} {1}".format(op.type, op.get_reference()))
+        if self.align is not None:
+            buf.append(", align {0}".format(self.align))
+        if self.metadata:
+            buf.append(self._stringify_metadata(leading_comma=True))
+
+
+class GEPInstr(Instruction):
+    def __init__(self, parent, ptr, indices, inbounds, name):
+        typ = ptr.type
+        lasttyp = None
+        lastaddrspace = 0
+        for i in indices:
+            lasttyp, typ = typ, typ.gep(i)
+            # inherit the addrspace from the last seen pointer
+            if isinstance(lasttyp, types.PointerType):
+                lastaddrspace = lasttyp.addrspace
+
+        if (not isinstance(typ, types.PointerType) and
+                isinstance(lasttyp, types.PointerType)):
+            typ = lasttyp
+        else:
+            typ = typ.as_pointer(lastaddrspace)
+
+        super(GEPInstr, self).__init__(parent, typ, "getelementptr",
+                                       [ptr] + list(indices), name=name)
+        self.pointer = ptr
+        self.indices = indices
+        self.inbounds = inbounds
+
+    def descr(self, buf):
+        indices = ['{0} {1}'.format(i.type, i.get_reference())
+                   for i in self.indices]
+        op = "getelementptr inbounds" if self.inbounds else "getelementptr"
+        buf.append("{0} {1}, {2} {3}, {4} {5}\n".format(
+                   op,
+                   self.pointer.type.pointee,
+                   self.pointer.type,
+                   self.pointer.get_reference(),
+                   ', '.join(indices),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class PhiInstr(Instruction):
+    def __init__(self, parent, typ, name, flags=()):
+        super(PhiInstr, self).__init__(parent, typ, "phi", (), name=name,
+                                       flags=flags)
+        self.incomings = []
+
+    def descr(self, buf):
+        incs = ', '.join('[{0}, {1}]'.format(v.get_reference(),
+                                             b.get_reference())
+                         for v, b in self.incomings)
+        buf.append("phi {0} {1} {2} {3}\n".format(
+                   ' '.join(self.flags),
+                   self.type,
+                   incs,
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+    def add_incoming(self, value, block):
+        assert isinstance(block, Block)
+        self.incomings.append((value, block))
+
+    def replace_usage(self, old, new):
+        self.incomings = [((new if val is old else val), blk)
+                          for (val, blk) in self.incomings]
+
+
+class ExtractElement(Instruction):
+    def __init__(self, parent, vector, index, name=''):
+        if not isinstance(vector.type, types.VectorType):
+            raise TypeError("vector needs to be of VectorType.")
+        if not isinstance(index.type, types.IntType):
+            raise TypeError("index needs to be of IntType.")
+        typ = vector.type.element
+        super(ExtractElement, self).__init__(parent, typ, "extractelement",
+                                             [vector, index], name=name)
+
+    def descr(self, buf):
+        operands = ", ".join("{0} {1}".format(
+                   op.type, op.get_reference()) for op in self.operands)
+        buf.append("{opname} {operands}\n".format(
+                   opname=self.opname, operands=operands))
+
+
+class InsertElement(Instruction):
+    def __init__(self, parent, vector, value, index, name=''):
+        if not isinstance(vector.type, types.VectorType):
+            raise TypeError("vector needs to be of VectorType.")
+        if not value.type == vector.type.element:
+            raise TypeError(
+                "value needs to be of type {} not {}.".format(
+                    vector.type.element, value.type))
+        if not isinstance(index.type, types.IntType):
+            raise TypeError("index needs to be of IntType.")
+        typ = vector.type
+        super(InsertElement, self).__init__(parent, typ, "insertelement",
+                                            [vector, value, index], name=name)
+
+    def descr(self, buf):
+        operands = ", ".join("{0} {1}".format(
+                   op.type, op.get_reference()) for op in self.operands)
+        buf.append("{opname} {operands}\n".format(
+                   opname=self.opname, operands=operands))
+
+
+class ShuffleVector(Instruction):
+    def __init__(self, parent, vector1, vector2, mask, name=''):
+        if not isinstance(vector1.type, types.VectorType):
+            raise TypeError("vector1 needs to be of VectorType.")
+        if vector2 != Undefined:
+            if vector2.type != vector1.type:
+                raise TypeError("vector2 needs to be " +
+                                "Undefined or of the same type as vector1.")
+        if (not isinstance(mask, Constant) or
+            not isinstance(mask.type, types.VectorType) or
+            not (isinstance(mask.type.element, types.IntType) and
+                 mask.type.element.width == 32)):
+            raise TypeError("mask needs to be a constant i32 vector.")
+        typ = types.VectorType(vector1.type.element, mask.type.count)
+        index_range = range(vector1.type.count
+                            if vector2 == Undefined
+                            else 2 * vector1.type.count)
+        if not all(ii.constant in index_range for ii in mask.constant):
+            raise IndexError(
+                "mask values need to be in {0}".format(index_range),
+            )
+        super(ShuffleVector, self).__init__(parent, typ, "shufflevector",
+                                            [vector1, vector2, mask], name=name)
+
+    def descr(self, buf):
+        buf.append("shufflevector {0} {1}\n".format(
+                   ", ".join("{0} {1}".format(op.type, op.get_reference())
+                             for op in self.operands),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class ExtractValue(Instruction):
+    def __init__(self, parent, agg, indices, name=''):
+        typ = agg.type
+        try:
+            for i in indices:
+                typ = typ.elements[i]
+        except (AttributeError, IndexError):
+            raise TypeError("Can't index at %r in %s"
+                            % (list(indices), agg.type))
+
+        super(ExtractValue, self).__init__(parent, typ, "extractvalue",
+                                           [agg], name=name)
+
+        self.aggregate = agg
+        self.indices = indices
+
+    def descr(self, buf):
+        indices = [str(i) for i in self.indices]
+
+        buf.append("extractvalue {0} {1}, {2} {3}\n".format(
+                   self.aggregate.type,
+                   self.aggregate.get_reference(),
+                   ', '.join(indices),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class InsertValue(Instruction):
+    def __init__(self, parent, agg, elem, indices, name=''):
+        typ = agg.type
+        try:
+            for i in indices:
+                typ = typ.elements[i]
+        except (AttributeError, IndexError):
+            raise TypeError("Can't index at %r in %s"
+                            % (list(indices), agg.type))
+        if elem.type != typ:
+            raise TypeError("Can only insert %s at %r in %s: got %s"
+                            % (typ, list(indices), agg.type, elem.type))
+        super(InsertValue, self).__init__(parent, agg.type, "insertvalue",
+                                          [agg, elem], name=name)
+
+        self.aggregate = agg
+        self.value = elem
+        self.indices = indices
+
+    def descr(self, buf):
+        indices = [str(i) for i in self.indices]
+
+        buf.append("insertvalue {0} {1}, {2} {3}, {4} {5}\n".format(
+                   self.aggregate.type, self.aggregate.get_reference(),
+                   self.value.type, self.value.get_reference(),
+                   ', '.join(indices),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class Unreachable(Instruction):
+    def __init__(self, parent):
+        super(Unreachable, self).__init__(parent, types.VoidType(),
+                                          "unreachable", (), name='')
+
+    def descr(self, buf):
+        buf += (self.opname, "\n")
+
+
+class InlineAsm(object):
+    def __init__(self, ftype, asm, constraint, side_effect=False):
+        self.type = ftype.return_type
+        self.function_type = ftype
+        self.asm = asm
+        self.constraint = constraint
+        self.side_effect = side_effect
+
+    def descr(self, buf):
+        sideeffect = 'sideeffect' if self.side_effect else ''
+        fmt = 'asm {sideeffect} "{asm}", "{constraint}"\n'
+        buf.append(fmt.format(sideeffect=sideeffect, asm=self.asm,
+                              constraint=self.constraint))
+
+    def get_reference(self):
+        buf = []
+        self.descr(buf)
+        return "".join(buf)
+
+    def __str__(self):
+        return "{0} {1}".format(self.type, self.get_reference())
+
+
+class AtomicRMW(Instruction):
+    def __init__(self, parent, op, ptr, val, ordering, name):
+        super(AtomicRMW, self).__init__(parent, val.type, "atomicrmw",
+                                        (ptr, val), name=name)
+        self.operation = op
+        self.ordering = ordering
+
+    def descr(self, buf):
+        ptr, val = self.operands
+        fmt = ("atomicrmw {op} {ptrty} {ptr}, {valty} {val} {ordering} "
+               "{metadata}\n")
+        buf.append(fmt.format(op=self.operation,
+                              ptrty=ptr.type,
+                              ptr=ptr.get_reference(),
+                              valty=val.type,
+                              val=val.get_reference(),
+                              ordering=self.ordering,
+                              metadata=self._stringify_metadata(
+                                  leading_comma=True),
+                              ))
+
+
+class CmpXchg(Instruction):
+    """This instruction has changed since llvm3.5.  It is not compatible with
+    older llvm versions.
+    """
+
+    def __init__(self, parent, ptr, cmp, val, ordering, failordering, name):
+        outtype = types.LiteralStructType([val.type, types.IntType(1)])
+        super(CmpXchg, self).__init__(parent, outtype, "cmpxchg",
+                                      (ptr, cmp, val), name=name)
+        self.ordering = ordering
+        self.failordering = failordering
+
+    def descr(self, buf):
+        ptr, cmpval, val = self.operands
+        fmt = "cmpxchg {ptrty} {ptr}, {ty} {cmp}, {ty} {val} {ordering} " \
+              "{failordering} {metadata}\n"
+        buf.append(fmt.format(ptrty=ptr.type,
+                              ptr=ptr.get_reference(),
+                              ty=cmpval.type,
+                              cmp=cmpval.get_reference(),
+                              val=val.get_reference(),
+                              ordering=self.ordering,
+                              failordering=self.failordering,
+                              metadata=self._stringify_metadata(
+                                  leading_comma=True),
+                              ))
+
+
+class _LandingPadClause(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{kind} {type} {value}".format(
+            kind=self.kind,
+            type=self.value.type,
+            value=self.value.get_reference())
+
+
+class CatchClause(_LandingPadClause):
+    kind = 'catch'
+
+
+class FilterClause(_LandingPadClause):
+    kind = 'filter'
+
+    def __init__(self, value):
+        assert isinstance(value, Constant)
+        assert isinstance(value.type, types.ArrayType)
+        super(FilterClause, self).__init__(value)
+
+
+class LandingPadInstr(Instruction):
+    def __init__(self, parent, typ, name='', cleanup=False):
+        super(LandingPadInstr, self).__init__(parent, typ, "landingpad", [],
+                                              name=name)
+        self.cleanup = cleanup
+        self.clauses = []
+
+    def add_clause(self, clause):
+        assert isinstance(clause, _LandingPadClause)
+        self.clauses.append(clause)
+
+    def descr(self, buf):
+        fmt = "landingpad {type}{cleanup}{clauses}\n"
+        buf.append(fmt.format(type=self.type,
+                              cleanup=' cleanup' if self.cleanup else '',
+                              clauses=''.join(["\n      {0}".format(clause)
+                                               for clause in self.clauses]),
+                              ))
+
+
+class Fence(Instruction):
+    """
+    The `fence` instruction.
+
+    As of LLVM 5.0.1:
+
+    fence [syncscope("<target-scope>")] <ordering>  ; yields void
+    """
+
+    VALID_FENCE_ORDERINGS = {"acquire", "release", "acq_rel", "seq_cst"}
+
+    def __init__(self, parent, ordering, targetscope=None, name=''):
+        super(Fence, self).__init__(parent, types.VoidType(), "fence", (),
+                                    name=name)
+        if ordering not in self.VALID_FENCE_ORDERINGS:
+            msg = "Invalid fence ordering \"{0}\"! Should be one of {1}."
+            raise ValueError(msg .format(ordering,
+                                         ", ".join(self.VALID_FENCE_ORDERINGS)))
+        self.ordering = ordering
+        self.targetscope = targetscope
+
+    def descr(self, buf):
+        if self.targetscope is None:
+            syncscope = ""
+        else:
+            syncscope = 'syncscope("{0}") '.format(self.targetscope)
+
+        fmt = "fence {syncscope}{ordering}\n"
+        buf.append(fmt.format(syncscope=syncscope,
+                              ordering=self.ordering,
+                              ))
+
+
+class Comment(Instruction):
+    """
+    A line comment.
+    """
+
+    def __init__(self, parent, text):
+        super(Comment, self).__init__(parent, types.VoidType(), ";", (),
+                                      name='')
+        assert "\n" not in text, "Comment cannot contain new line"
+        self.text = text
+
+    def descr(self, buf):
+        buf.append(f"; {self.text}")

vllm/lib/python3.10/site-packages/llvmlite/ir/module.py

@@ -0,0 +1,246 @@
+import collections
+
+from llvmlite.ir import context, values, types, _utils
+
+
+class Module(object):
+    def __init__(self, name='', context=context.global_context):
+        self.context = context
+        self.name = name   # name is for debugging/informational
+        self.data_layout = ""
+        self.scope = _utils.NameScope()
+        self.triple = 'unknown-unknown-unknown'
+        self.globals = collections.OrderedDict()
+        # Innamed metadata nodes.
+        self.metadata = []
+        # Named metadata nodes
+        self.namedmetadata = {}
+        # Cache for metadata node deduplication
+        self._metadatacache = {}
+
+    def _fix_metadata_operands(self, operands):
+        fixed_ops = []
+        for op in operands:
+            if op is None:
+                # A literal None creates a null metadata value
+                op = types.MetaDataType()(None)
+            elif isinstance(op, str):
+                # A literal string creates a metadata string value
+                op = values.MetaDataString(self, op)
+            elif isinstance(op, (list, tuple)):
+                # A sequence creates a metadata node reference
+                op = self.add_metadata(op)
+            fixed_ops.append(op)
+        return fixed_ops
+
+    def _fix_di_operands(self, operands):
+        fixed_ops = []
+        for name, op in operands:
+            if isinstance(op, (list, tuple)):
+                # A sequence creates a metadata node reference
+                op = self.add_metadata(op)
+            fixed_ops.append((name, op))
+        return fixed_ops
+
+    def add_metadata(self, operands):
+        """
+        Add an unnamed metadata to the module with the given *operands*
+        (a sequence of values) or return a previous equivalent metadata.
+        A MDValue instance is returned, it can then be associated to
+        e.g. an instruction.
+        """
+        if not isinstance(operands, (list, tuple)):
+            raise TypeError("expected a list or tuple of metadata values, "
+                            "got %r" % (operands,))
+        operands = self._fix_metadata_operands(operands)
+        key = tuple(operands)
+        if key not in self._metadatacache:
+            n = len(self.metadata)
+            md = values.MDValue(self, operands, name=str(n))
+            self._metadatacache[key] = md
+        else:
+            md = self._metadatacache[key]
+        return md
+
+    def add_debug_info(self, kind, operands, is_distinct=False):
+        """
+        Add debug information metadata to the module with the given
+        *operands* (a dict of values with string keys) or return
+        a previous equivalent metadata.  *kind* is a string of the
+        debug information kind (e.g. "DICompileUnit").
+
+        A DIValue instance is returned, it can then be associated to e.g.
+        an instruction.
+        """
+        operands = tuple(sorted(self._fix_di_operands(operands.items())))
+        key = (kind, operands, is_distinct)
+        if key not in self._metadatacache:
+            n = len(self.metadata)
+            di = values.DIValue(self, is_distinct, kind, operands, name=str(n))
+            self._metadatacache[key] = di
+        else:
+            di = self._metadatacache[key]
+        return di
+
+    def add_named_metadata(self, name, element=None):
+        """
+        Add a named metadata node to the module, if it doesn't exist,
+        or return the existing node.
+        If *element* is given, it will append a new element to
+        the named metadata node.  If *element* is a sequence of values
+        (rather than a metadata value), a new unnamed node will first be
+        created.
+
+        Example::
+            module.add_named_metadata("llvm.ident", ["llvmlite/1.0"])
+        """
+        if name in self.namedmetadata:
+            nmd = self.namedmetadata[name]
+        else:
+            nmd = self.namedmetadata[name] = values.NamedMetaData(self)
+        if element is not None:
+            if not isinstance(element, values.Value):
+                element = self.add_metadata(element)
+            if not isinstance(element.type, types.MetaDataType):
+                raise TypeError("wrong type for metadata element: got %r"
+                                % (element,))
+            nmd.add(element)
+        return nmd
+
+    def get_named_metadata(self, name):
+        """
+        Return the metadata node with the given *name*.  KeyError is raised
+        if no such node exists (contrast with add_named_metadata()).
+        """
+        return self.namedmetadata[name]
+
+    @property
+    def functions(self):
+        """
+        A list of functions declared or defined in this module.
+        """
+        return [v for v in self.globals.values()
+                if isinstance(v, values.Function)]
+
+    @property
+    def global_values(self):
+        """
+        An iterable of global values in this module.
+        """
+        return self.globals.values()
+
+    def get_global(self, name):
+        """
+        Get a global value by name.
+        """
+        return self.globals[name]
+
+    def add_global(self, globalvalue):
+        """
+        Add a new global value.
+        """
+        assert globalvalue.name not in self.globals
+        self.globals[globalvalue.name] = globalvalue
+
+    def get_unique_name(self, name=''):
+        """
+        Get a unique global name with the following *name* hint.
+        """
+        return self.scope.deduplicate(name)
+
+    def declare_intrinsic(self, intrinsic, tys=(), fnty=None):
+        def _error():
+            raise NotImplementedError("unknown intrinsic %r with %d types"
+                                      % (intrinsic, len(tys)))
+
+        if intrinsic in {'llvm.cttz', 'llvm.ctlz', 'llvm.fma'}:
+            suffixes = [tys[0].intrinsic_name]
+        else:
+            suffixes = [t.intrinsic_name for t in tys]
+        name = '.'.join([intrinsic] + suffixes)
+        if name in self.globals:
+            return self.globals[name]
+
+        if fnty is not None:
+            # General case: function type is given
+            pass
+        # Compute function type if omitted for common cases
+        elif len(tys) == 0 and intrinsic == 'llvm.assume':
+            fnty = types.FunctionType(types.VoidType(), [types.IntType(1)])
+        elif len(tys) == 1:
+            if intrinsic == 'llvm.powi':
+                fnty = types.FunctionType(tys[0], [tys[0], types.IntType(32)])
+            elif intrinsic == 'llvm.pow':
+                fnty = types.FunctionType(tys[0], tys * 2)
+            elif intrinsic == 'llvm.convert.from.fp16':
+                fnty = types.FunctionType(tys[0], [types.IntType(16)])
+            elif intrinsic == 'llvm.convert.to.fp16':
+                fnty = types.FunctionType(types.IntType(16), tys)
+            else:
+                fnty = types.FunctionType(tys[0], tys)
+        elif len(tys) == 2:
+            if intrinsic == 'llvm.memset':
+                tys = [tys[0], types.IntType(8), tys[1],
+                       types.IntType(1)]
+                fnty = types.FunctionType(types.VoidType(), tys)
+            elif intrinsic in {'llvm.cttz', 'llvm.ctlz'}:
+                tys = [tys[0], types.IntType(1)]
+                fnty = types.FunctionType(tys[0], tys)
+            else:
+                _error()
+        elif len(tys) == 3:
+            if intrinsic in ('llvm.memcpy', 'llvm.memmove'):
+                tys = tys + [types.IntType(1)]
+                fnty = types.FunctionType(types.VoidType(), tys)
+            elif intrinsic == 'llvm.fma':
+                tys = [tys[0]] * 3
+                fnty = types.FunctionType(tys[0], tys)
+            else:
+                _error()
+        else:
+            _error()
+        return values.Function(self, fnty, name=name)
+
+    def get_identified_types(self):
+        return self.context.identified_types
+
+    def _get_body_lines(self):
+        # Type declarations
+        lines = [it.get_declaration()
+                 for it in self.get_identified_types().values()]
+        # Global values (including function definitions)
+        lines += [str(v) for v in self.globals.values()]
+        return lines
+
+    def _get_metadata_lines(self):
+        mdbuf = []
+        for k, v in self.namedmetadata.items():
+            mdbuf.append("!{name} = !{{ {operands} }}".format(
+                name=k, operands=', '.join(i.get_reference()
+                                           for i in v.operands)))
+        for md in self.metadata:
+            mdbuf.append(str(md))
+        return mdbuf
+
+    def _stringify_body(self):
+        # For testing
+        return "\n".join(self._get_body_lines())
+
+    def _stringify_metadata(self):
+        # For testing
+        return "\n".join(self._get_metadata_lines())
+
+    def __repr__(self):
+        lines = []
+        # Header
+        lines += [
+            '; ModuleID = "%s"' % (self.name,),
+            'target triple = "%s"' % (self.triple,),
+            'target datalayout = "%s"' % (self.data_layout,),
+            '']
+        # Body
+        lines += self._get_body_lines()
+        # Metadata
+        lines += self._get_metadata_lines()
+
+        return "\n".join(lines)

vllm/lib/python3.10/site-packages/llvmlite/ir/transforms.py

@@ -0,0 +1,64 @@
+from llvmlite.ir import CallInstr
+
+
+class Visitor(object):
+    def visit(self, module):
+        self._module = module
+        for func in module.functions:
+            self.visit_Function(func)
+
+    def visit_Function(self, func):
+        self._function = func
+        for bb in func.blocks:
+            self.visit_BasicBlock(bb)
+
+    def visit_BasicBlock(self, bb):
+        self._basic_block = bb
+        for instr in bb.instructions:
+            self.visit_Instruction(instr)
+
+    def visit_Instruction(self, instr):
+        raise NotImplementedError
+
+    @property
+    def module(self):
+        return self._module
+
+    @property
+    def function(self):
+        return self._function
+
+    @property
+    def basic_block(self):
+        return self._basic_block
+
+
+class CallVisitor(Visitor):
+    def visit_Instruction(self, instr):
+        if isinstance(instr, CallInstr):
+            self.visit_Call(instr)
+
+    def visit_Call(self, instr):
+        raise NotImplementedError
+
+
+class ReplaceCalls(CallVisitor):
+    def __init__(self, orig, repl):
+        super(ReplaceCalls, self).__init__()
+        self.orig = orig
+        self.repl = repl
+        self.calls = []
+
+    def visit_Call(self, instr):
+        if instr.callee == self.orig:
+            instr.replace_callee(self.repl)
+            self.calls.append(instr)
+
+
+def replace_all_calls(mod, orig, repl):
+    """Replace all calls to `orig` to `repl` in module `mod`.
+    Returns the references to the returned calls
+    """
+    rc = ReplaceCalls(orig, repl)
+    rc.visit(mod)
+    return rc.calls

vllm/lib/python3.10/site-packages/llvmlite/ir/types.py

@@ -0,0 +1,614 @@
+"""
+Classes that are LLVM types
+"""
+
+import struct
+
+from llvmlite.ir._utils import _StrCaching
+
+
+def _wrapname(x):
+    return '"{0}"'.format(x.replace('\\', '\\5c').replace('"', '\\22'))
+
+
+class Type(_StrCaching):
+    """
+    The base class for all LLVM types.
+    """
+    is_pointer = False
+    null = 'zeroinitializer'
+
+    def __repr__(self):
+        return "<%s %s>" % (type(self), str(self))
+
+    def _to_string(self):
+        raise NotImplementedError
+
+    def as_pointer(self, addrspace=0):
+        return PointerType(self, addrspace)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def _get_ll_pointer_type(self, target_data, context=None):
+        """
+        Convert this type object to an LLVM type.
+        """
+        from llvmlite.ir import Module, GlobalVariable
+        from llvmlite.binding import parse_assembly
+
+        if context is None:
+            m = Module()
+        else:
+            m = Module(context=context)
+        foo = GlobalVariable(m, self, name="foo")
+        with parse_assembly(str(m)) as llmod:
+            return llmod.get_global_variable(foo.name).type
+
+    def get_abi_size(self, target_data, context=None):
+        """
+        Get the ABI size of this type according to data layout *target_data*.
+        """
+        llty = self._get_ll_pointer_type(target_data, context)
+        return target_data.get_pointee_abi_size(llty)
+
+    def get_abi_alignment(self, target_data, context=None):
+        """
+        Get the minimum ABI alignment of this type according to data layout
+        *target_data*.
+        """
+        llty = self._get_ll_pointer_type(target_data, context)
+        return target_data.get_pointee_abi_alignment(llty)
+
+    def format_constant(self, value):
+        """
+        Format constant *value* of this type.  This method may be overriden
+        by subclasses.
+        """
+        return str(value)
+
+    def wrap_constant_value(self, value):
+        """
+        Wrap constant *value* if necessary.  This method may be overriden
+        by subclasses (especially aggregate types).
+        """
+        return value
+
+    def __call__(self, value):
+        """
+        Create a LLVM constant of this type with the given Python value.
+        """
+        from llvmlite.ir import Constant
+        return Constant(self, value)
+
+
+class MetaDataType(Type):
+
+    def _to_string(self):
+        return "metadata"
+
+    def as_pointer(self):
+        raise TypeError
+
+    def __eq__(self, other):
+        return isinstance(other, MetaDataType)
+
+    def __hash__(self):
+        return hash(MetaDataType)
+
+
+class LabelType(Type):
+    """
+    The label type is the type of e.g. basic blocks.
+    """
+
+    def _to_string(self):
+        return "label"
+
+
+class PointerType(Type):
+    """
+    The type of all pointer values.
+    """
+    is_pointer = True
+    null = 'null'
+
+    def __init__(self, pointee, addrspace=0):
+        assert not isinstance(pointee, VoidType)
+        self.pointee = pointee
+        self.addrspace = addrspace
+
+    def _to_string(self):
+        if self.addrspace != 0:
+            return "{0} addrspace({1})*".format(self.pointee, self.addrspace)
+        else:
+            return "{0}*".format(self.pointee)
+
+    def __eq__(self, other):
+        if isinstance(other, PointerType):
+            return (self.pointee, self.addrspace) == (other.pointee,
+                                                      other.addrspace)
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(PointerType)
+
+    def gep(self, i):
+        """
+        Resolve the type of the i-th element (for getelementptr lookups).
+        """
+        if not isinstance(i.type, IntType):
+            raise TypeError(i.type)
+        return self.pointee
+
+    @property
+    def intrinsic_name(self):
+        return 'p%d%s' % (self.addrspace, self.pointee.intrinsic_name)
+
+
+class VoidType(Type):
+    """
+    The type for empty values (e.g. a function returning no value).
+    """
+
+    def _to_string(self):
+        return 'void'
+
+    def __eq__(self, other):
+        return isinstance(other, VoidType)
+
+    def __hash__(self):
+        return hash(VoidType)
+
+
+class FunctionType(Type):
+    """
+    The type for functions.
+    """
+
+    def __init__(self, return_type, args, var_arg=False):
+        self.return_type = return_type
+        self.args = tuple(args)
+        self.var_arg = var_arg
+
+    def _to_string(self):
+        if self.args:
+            strargs = ', '.join([str(a) for a in self.args])
+            if self.var_arg:
+                return '{0} ({1}, ...)'.format(self.return_type, strargs)
+            else:
+                return '{0} ({1})'.format(self.return_type, strargs)
+        elif self.var_arg:
+            return '{0} (...)'.format(self.return_type)
+        else:
+            return '{0} ()'.format(self.return_type)
+
+    def __eq__(self, other):
+        if isinstance(other, FunctionType):
+            return (self.return_type == other.return_type and
+                    self.args == other.args and self.var_arg == other.var_arg)
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(FunctionType)
+
+
+class IntType(Type):
+    """
+    The type for integers.
+    """
+    null = '0'
+    _instance_cache = {}
+    width: int
+
+    def __new__(cls, bits):
+        # Cache all common integer types
+        if 0 <= bits <= 128:
+            try:
+                return cls._instance_cache[bits]
+            except KeyError:
+                inst = cls._instance_cache[bits] = cls.__new(bits)
+                return inst
+        return cls.__new(bits)
+
+    @classmethod
+    def __new(cls, bits):
+        assert isinstance(bits, int) and bits >= 0
+        self = super(IntType, cls).__new__(cls)
+        self.width = bits
+        return self
+
+    def __getnewargs__(self):
+        return self.width,
+
+    def __copy__(self):
+        return self
+
+    def _to_string(self):
+        return 'i%u' % (self.width,)
+
+    def __eq__(self, other):
+        if isinstance(other, IntType):
+            return self.width == other.width
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(IntType)
+
+    def format_constant(self, val):
+        if isinstance(val, bool):
+            return str(val).lower()
+        else:
+            return str(val)
+
+    def wrap_constant_value(self, val):
+        if val is None:
+            return 0
+        return val
+
+    @property
+    def intrinsic_name(self):
+        return str(self)
+
+
+def _as_float(value):
+    """
+    Truncate to single-precision float.
+    """
+    return struct.unpack('f', struct.pack('f', value))[0]
+
+
+def _as_half(value):
+    """
+    Truncate to half-precision float.
+    """
+    try:
+        return struct.unpack('e', struct.pack('e', value))[0]
+    except struct.error:
+        # 'e' only added in Python 3.6+
+        return _as_float(value)
+
+
+def _format_float_as_hex(value, packfmt, unpackfmt, numdigits):
+    raw = struct.pack(packfmt, float(value))
+    intrep = struct.unpack(unpackfmt, raw)[0]
+    out = '{{0:#{0}x}}'.format(numdigits).format(intrep)
+    return out
+
+
+def _format_double(value):
+    """
+    Format *value* as a hexadecimal string of its IEEE double precision
+    representation.
+    """
+    return _format_float_as_hex(value, 'd', 'Q', 16)
+
+
+class _BaseFloatType(Type):
+
+    def __new__(cls):
+        return cls._instance_cache
+
+    def __eq__(self, other):
+        return isinstance(other, type(self))
+
+    def __hash__(self):
+        return hash(type(self))
+
+    @classmethod
+    def _create_instance(cls):
+        cls._instance_cache = super(_BaseFloatType, cls).__new__(cls)
+
+
+class HalfType(_BaseFloatType):
+    """
+    The type for single-precision floats.
+    """
+    null = '0.0'
+    intrinsic_name = 'f16'
+
+    def __str__(self):
+        return 'half'
+
+    def format_constant(self, value):
+        return _format_double(_as_half(value))
+
+
+class FloatType(_BaseFloatType):
+    """
+    The type for single-precision floats.
+    """
+    null = '0.0'
+    intrinsic_name = 'f32'
+
+    def __str__(self):
+        return 'float'
+
+    def format_constant(self, value):
+        return _format_double(_as_float(value))
+
+
+class DoubleType(_BaseFloatType):
+    """
+    The type for double-precision floats.
+    """
+    null = '0.0'
+    intrinsic_name = 'f64'
+
+    def __str__(self):
+        return 'double'
+
+    def format_constant(self, value):
+        return _format_double(value)
+
+
+for _cls in (HalfType, FloatType, DoubleType):
+    _cls._create_instance()
+
+
+class _Repeat(object):
+    def __init__(self, value, size):
+        self.value = value
+        self.size = size
+
+    def __len__(self):
+        return self.size
+
+    def __getitem__(self, item):
+        if 0 <= item < self.size:
+            return self.value
+        else:
+            raise IndexError(item)
+
+
+class VectorType(Type):
+    """
+    The type for vectors of primitive data items (e.g. "<f32 x 4>").
+    """
+
+    def __init__(self, element, count):
+        self.element = element
+        self.count = count
+
+    @property
+    def elements(self):
+        return _Repeat(self.element, self.count)
+
+    def __len__(self):
+        return self.count
+
+    def _to_string(self):
+        return "<%d x %s>" % (self.count, self.element)
+
+    def __eq__(self, other):
+        if isinstance(other, VectorType):
+            return self.element == other.element and self.count == other.count
+
+    def __hash__(self):
+        # TODO: why does this not take self.element/self.count into account?
+        return hash(VectorType)
+
+    def __copy__(self):
+        return self
+
+    def format_constant(self, value):
+        itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference())
+                                 for x in value])
+        return "<{0}>".format(itemstring)
+
+    def wrap_constant_value(self, values):
+        from . import Value, Constant
+        if not isinstance(values, (list, tuple)):
+            if isinstance(values, Constant):
+                if values.type != self.element:
+                    raise TypeError("expected {} for {}".format(
+                        self.element, values.type))
+                return (values, ) * self.count
+            return (Constant(self.element, values), ) * self.count
+        if len(values) != len(self):
+            raise ValueError("wrong constant size for %s: got %d elements"
+                             % (self, len(values)))
+        return [Constant(ty, val) if not isinstance(val, Value) else val
+                for ty, val in zip(self.elements, values)]
+
+
+class Aggregate(Type):
+    """
+    Base class for aggregate types.
+    See http://llvm.org/docs/LangRef.html#t-aggregate
+    """
+
+    def wrap_constant_value(self, values):
+        from . import Value, Constant
+
+        if not isinstance(values, (list, tuple)):
+            return values
+        if len(values) != len(self):
+            raise ValueError("wrong constant size for %s: got %d elements"
+                             % (self, len(values)))
+        return [Constant(ty, val) if not isinstance(val, Value) else val
+                for ty, val in zip(self.elements, values)]
+
+
+class ArrayType(Aggregate):
+    """
+    The type for fixed-size homogenous arrays (e.g. "[f32 x 3]").
+    """
+
+    def __init__(self, element, count):
+        self.element = element
+        self.count = count
+
+    @property
+    def elements(self):
+        return _Repeat(self.element, self.count)
+
+    def __len__(self):
+        return self.count
+
+    def _to_string(self):
+        return "[%d x %s]" % (self.count, self.element)
+
+    def __eq__(self, other):
+        if isinstance(other, ArrayType):
+            return self.element == other.element and self.count == other.count
+
+    def __hash__(self):
+        return hash(ArrayType)
+
+    def gep(self, i):
+        """
+        Resolve the type of the i-th element (for getelementptr lookups).
+        """
+        if not isinstance(i.type, IntType):
+            raise TypeError(i.type)
+        return self.element
+
+    def format_constant(self, value):
+        itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference())
+                                 for x in value])
+        return "[{0}]".format(itemstring)
+
+
+class BaseStructType(Aggregate):
+    """
+    The base type for heterogenous struct types.
+    """
+    _packed = False
+
+    @property
+    def packed(self):
+        """
+        A boolean attribute that indicates whether the structure uses
+        packed layout.
+        """
+        return self._packed
+
+    @packed.setter
+    def packed(self, val):
+        self._packed = bool(val)
+
+    def __len__(self):
+        assert self.elements is not None
+        return len(self.elements)
+
+    def __iter__(self):
+        assert self.elements is not None
+        return iter(self.elements)
+
+    @property
+    def is_opaque(self):
+        return self.elements is None
+
+    def structure_repr(self):
+        """
+        Return the LLVM IR for the structure representation
+        """
+        ret = '{%s}' % ', '.join([str(x) for x in self.elements])
+        return self._wrap_packed(ret)
+
+    def format_constant(self, value):
+        itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference())
+                                 for x in value])
+        ret = "{{{0}}}".format(itemstring)
+        return self._wrap_packed(ret)
+
+    def gep(self, i):
+        """
+        Resolve the type of the i-th element (for getelementptr lookups).
+
+        *i* needs to be a LLVM constant, so that the type can be determined
+        at compile-time.
+        """
+        if not isinstance(i.type, IntType):
+            raise TypeError(i.type)
+        return self.elements[i.constant]
+
+    def _wrap_packed(self, textrepr):
+        """
+        Internal helper to wrap textual repr of struct type into packed struct
+        """
+        if self.packed:
+            return '<{}>'.format(textrepr)
+        else:
+            return textrepr
+
+
+class LiteralStructType(BaseStructType):
+    """
+    The type of "literal" structs, i.e. structs with a literally-defined
+    type (by contrast with IdentifiedStructType).
+    """
+
+    null = 'zeroinitializer'
+
+    def __init__(self, elems, packed=False):
+        """
+        *elems* is a sequence of types to be used as members.
+        *packed* controls the use of packed layout.
+        """
+        self.elements = tuple(elems)
+        self.packed = packed
+
+    def _to_string(self):
+        return self.structure_repr()
+
+    def __eq__(self, other):
+        if isinstance(other, LiteralStructType):
+            return self.elements == other.elements
+
+    def __hash__(self):
+        return hash(LiteralStructType)
+
+
+class IdentifiedStructType(BaseStructType):
+    """
+    A type which is a named alias for another struct type, akin to a typedef.
+    While literal struct types can be structurally equal (see
+    LiteralStructType), identified struct types are compared by name.
+
+    Do not use this directly.
+    """
+    null = 'zeroinitializer'
+
+    def __init__(self, context, name, packed=False):
+        """
+        *context* is a llvmlite.ir.Context.
+        *name* is the identifier for the new struct type.
+        *packed* controls the use of packed layout.
+        """
+        assert name
+        self.context = context
+        self.name = name
+        self.elements = None
+        self.packed = packed
+
+    def _to_string(self):
+        return "%{name}".format(name=_wrapname(self.name))
+
+    def get_declaration(self):
+        """
+        Returns the string for the declaration of the type
+        """
+        if self.is_opaque:
+            out = "{strrep} = type opaque".format(strrep=str(self))
+        else:
+            out = "{strrep} = type {struct}".format(
+                strrep=str(self), struct=self.structure_repr())
+        return out
+
+    def __eq__(self, other):
+        if isinstance(other, IdentifiedStructType):
+            return self.name == other.name
+
+    def __hash__(self):
+        return hash(IdentifiedStructType)
+
+    def set_body(self, *elems):
+        if not self.is_opaque:
+            raise RuntimeError("{name} is already defined".format(
+                name=self.name))
+        self.elements = tuple(elems)

vllm/lib/python3.10/site-packages/llvmlite/ir/values.py

@@ -0,0 +1,1217 @@
+"""
+Classes that are LLVM values: Value, Constant...
+Instructions are in the instructions module.
+"""
+
+import functools
+import string
+import re
+from types import MappingProxyType
+
+from llvmlite.ir import values, types, _utils
+from llvmlite.ir._utils import (_StrCaching, _StringReferenceCaching,
+                                _HasMetadata)
+
+_VALID_CHARS = (frozenset(map(ord, string.ascii_letters)) |
+                frozenset(map(ord, string.digits)) |
+                frozenset(map(ord, ' !#$%&\'()*+,-./:;<=>?@[]^_`{|}~')))
+
+_SIMPLE_IDENTIFIER_RE = re.compile(r"[-a-zA-Z$._][-a-zA-Z$._0-9]*$")
+
+_CMP_MAP = {
+    '>': 'gt',
+    '<': 'lt',
+    '==': 'eq',
+    '!=': 'ne',
+    '>=': 'ge',
+    '<=': 'le',
+}
+
+
+def _escape_string(text, _map={}):
+    """
+    Escape the given bytestring for safe use as a LLVM array constant.
+    Any unicode string input is first encoded with utf8 into bytes.
+    """
+    if isinstance(text, str):
+        text = text.encode()
+    assert isinstance(text, (bytes, bytearray))
+
+    if not _map:
+        for ch in range(256):
+            if ch in _VALID_CHARS:
+                _map[ch] = chr(ch)
+            else:
+                _map[ch] = '\\%02x' % ch
+
+    buf = [_map[ch] for ch in text]
+    return ''.join(buf)
+
+
+def _binop(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(lhs, rhs):
+            if lhs.type != rhs.type:
+                raise ValueError("Operands must be the same type, got (%s, %s)"
+                                 % (lhs.type, rhs.type))
+
+            fmt = "{0} ({1} {2}, {3} {4})".format(opname,
+                                                  lhs.type, lhs.get_reference(),
+                                                  rhs.type, rhs.get_reference())
+            return FormattedConstant(lhs.type, fmt)
+
+        return wrapped
+    return wrap
+
+
+def _castop(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, typ):
+            fn(self, typ)
+            if typ == self.type:
+                return self
+
+            op = "{0} ({1} {2} to {3})".format(opname, self.type,
+                                               self.get_reference(), typ)
+            return FormattedConstant(typ, op)
+
+        return wrapped
+    return wrap
+
+
+class _ConstOpMixin(object):
+    """
+    A mixin defining constant operations, for use in constant-like classes.
+    """
+
+    #
+    # Arithmetic APIs
+    #
+
+    @_binop('shl')
+    def shl(self, other):
+        """
+        Left integer shift:
+            lhs << rhs
+        """
+
+    @_binop('lshr')
+    def lshr(self, other):
+        """
+        Logical (unsigned) right integer shift:
+            lhs >> rhs
+        """
+
+    @_binop('ashr')
+    def ashr(self, other):
+        """
+        Arithmetic (signed) right integer shift:
+            lhs >> rhs
+        """
+
+    @_binop('add')
+    def add(self, other):
+        """
+        Integer addition:
+            lhs + rhs
+        """
+
+    @_binop('fadd')
+    def fadd(self, other):
+        """
+        Floating-point addition:
+            lhs + rhs
+        """
+
+    @_binop('sub')
+    def sub(self, other):
+        """
+        Integer subtraction:
+            lhs - rhs
+        """
+
+    @_binop('fsub')
+    def fsub(self, other):
+        """
+        Floating-point subtraction:
+            lhs - rhs
+        """
+
+    @_binop('mul')
+    def mul(self, other):
+        """
+        Integer multiplication:
+            lhs * rhs
+        """
+
+    @_binop('fmul')
+    def fmul(self, other):
+        """
+        Floating-point multiplication:
+            lhs * rhs
+        """
+
+    @_binop('udiv')
+    def udiv(self, other):
+        """
+        Unsigned integer division:
+            lhs / rhs
+        """
+
+    @_binop('sdiv')
+    def sdiv(self, other):
+        """
+        Signed integer division:
+            lhs / rhs
+        """
+
+    @_binop('fdiv')
+    def fdiv(self, other):
+        """
+        Floating-point division:
+            lhs / rhs
+        """
+
+    @_binop('urem')
+    def urem(self, other):
+        """
+        Unsigned integer remainder:
+            lhs % rhs
+        """
+
+    @_binop('srem')
+    def srem(self, other):
+        """
+        Signed integer remainder:
+            lhs % rhs
+        """
+
+    @_binop('frem')
+    def frem(self, other):
+        """
+        Floating-point remainder:
+            lhs % rhs
+        """
+
+    @_binop('or')
+    def or_(self, other):
+        """
+        Bitwise integer OR:
+            lhs | rhs
+        """
+
+    @_binop('and')
+    def and_(self, other):
+        """
+        Bitwise integer AND:
+            lhs & rhs
+        """
+
+    @_binop('xor')
+    def xor(self, other):
+        """
+        Bitwise integer XOR:
+            lhs ^ rhs
+        """
+
+    def _cmp(self, prefix, sign, cmpop, other):
+        ins = prefix + 'cmp'
+        try:
+            op = _CMP_MAP[cmpop]
+        except KeyError:
+            raise ValueError("invalid comparison %r for %s" % (cmpop, ins))
+
+        if not (prefix == 'i' and cmpop in ('==', '!=')):
+            op = sign + op
+
+        if self.type != other.type:
+            raise ValueError("Operands must be the same type, got (%s, %s)"
+                             % (self.type, other.type))
+
+        fmt = "{0} {1} ({2} {3}, {4} {5})".format(
+            ins, op,
+            self.type, self.get_reference(),
+            other.type, other.get_reference())
+
+        return FormattedConstant(types.IntType(1), fmt)
+
+    def icmp_signed(self, cmpop, other):
+        """
+        Signed integer comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._cmp('i', 's', cmpop, other)
+
+    def icmp_unsigned(self, cmpop, other):
+        """
+        Unsigned integer (or pointer) comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._cmp('i', 'u', cmpop, other)
+
+    def fcmp_ordered(self, cmpop, other):
+        """
+        Floating-point ordered comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        return self._cmp('f', 'o', cmpop, other)
+
+    def fcmp_unordered(self, cmpop, other):
+        """
+        Floating-point unordered comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        return self._cmp('f', 'u', cmpop, other)
+
+    #
+    # Unary APIs
+    #
+
+    def not_(self):
+        """
+        Bitwise integer complement:
+            ~value
+        """
+        if isinstance(self.type, types.VectorType):
+            rhs = values.Constant(self.type, (-1,) * self.type.count)
+        else:
+            rhs = values.Constant(self.type, -1)
+
+        return self.xor(rhs)
+
+    def neg(self):
+        """
+        Integer negative:
+            -value
+        """
+        zero = values.Constant(self.type, 0)
+        return zero.sub(self)
+
+    def fneg(self):
+        """
+        Floating-point negative:
+            -value
+        """
+        fmt = "fneg ({0} {1})".format(self.type, self.get_reference())
+        return FormattedConstant(self.type, fmt)
+
+    #
+    # Cast APIs
+    #
+
+    @_castop('trunc')
+    def trunc(self, typ):
+        """
+        Truncating integer downcast to a smaller type.
+        """
+
+    @_castop('zext')
+    def zext(self, typ):
+        """
+        Zero-extending integer upcast to a larger type
+        """
+
+    @_castop('sext')
+    def sext(self, typ):
+        """
+        Sign-extending integer upcast to a larger type.
+        """
+
+    @_castop('fptrunc')
+    def fptrunc(self, typ):
+        """
+        Floating-point downcast to a less precise type.
+        """
+
+    @_castop('fpext')
+    def fpext(self, typ):
+        """
+        Floating-point upcast to a more precise type.
+        """
+
+    @_castop('bitcast')
+    def bitcast(self, typ):
+        """
+        Pointer cast to a different pointer type.
+        """
+
+    @_castop('fptoui')
+    def fptoui(self, typ):
+        """
+        Convert floating-point to unsigned integer.
+        """
+
+    @_castop('uitofp')
+    def uitofp(self, typ):
+        """
+        Convert unsigned integer to floating-point.
+        """
+
+    @_castop('fptosi')
+    def fptosi(self, typ):
+        """
+        Convert floating-point to signed integer.
+        """
+
+    @_castop('sitofp')
+    def sitofp(self, typ):
+        """
+        Convert signed integer to floating-point.
+        """
+
+    @_castop('ptrtoint')
+    def ptrtoint(self, typ):
+        """
+        Cast pointer to integer.
+        """
+        if not isinstance(self.type, types.PointerType):
+            msg = "can only call ptrtoint() on pointer type, not '%s'"
+            raise TypeError(msg % (self.type,))
+        if not isinstance(typ, types.IntType):
+            raise TypeError("can only ptrtoint() to integer type, not '%s'"
+                            % (typ,))
+
+    @_castop('inttoptr')
+    def inttoptr(self, typ):
+        """
+        Cast integer to pointer.
+        """
+        if not isinstance(self.type, types.IntType):
+            msg = "can only call inttoptr() on integer constants, not '%s'"
+            raise TypeError(msg % (self.type,))
+        if not isinstance(typ, types.PointerType):
+            raise TypeError("can only inttoptr() to pointer type, not '%s'"
+                            % (typ,))
+
+    def gep(self, indices):
+        """
+        Call getelementptr on this pointer constant.
+        """
+        if not isinstance(self.type, types.PointerType):
+            raise TypeError("can only call gep() on pointer constants, not '%s'"
+                            % (self.type,))
+
+        outtype = self.type
+        for i in indices:
+            outtype = outtype.gep(i)
+
+        strindices = ["{0} {1}".format(idx.type, idx.get_reference())
+                      for idx in indices]
+
+        op = "getelementptr ({0}, {1} {2}, {3})".format(
+            self.type.pointee, self.type,
+            self.get_reference(), ', '.join(strindices))
+        return FormattedConstant(outtype.as_pointer(self.addrspace), op)
+
+
+class Value(object):
+    """
+    The base class for all values.
+    """
+
+    def __repr__(self):
+        return "<ir.%s type='%s' ...>" % (self.__class__.__name__, self.type,)
+
+
+class _Undefined(object):
+    """
+    'undef': a value for undefined values.
+    """
+    def __new__(cls):
+        try:
+            return Undefined
+        except NameError:
+            return object.__new__(_Undefined)
+
+
+Undefined = _Undefined()
+
+
+class Constant(_StrCaching, _StringReferenceCaching, _ConstOpMixin, Value):
+    """
+    A constant LLVM value.
+    """
+
+    def __init__(self, typ, constant):
+        assert isinstance(typ, types.Type)
+        assert not isinstance(typ, types.VoidType)
+        self.type = typ
+        constant = typ.wrap_constant_value(constant)
+        self.constant = constant
+
+    def _to_string(self):
+        return '{0} {1}'.format(self.type, self.get_reference())
+
+    def _get_reference(self):
+        if self.constant is None:
+            val = self.type.null
+
+        elif self.constant is Undefined:
+            val = "undef"
+
+        elif isinstance(self.constant, bytearray):
+            val = 'c"{0}"'.format(_escape_string(self.constant))
+
+        else:
+            val = self.type.format_constant(self.constant)
+
+        return val
+
+    @classmethod
+    def literal_array(cls, elems):
+        """
+        Construct a literal array constant made of the given members.
+        """
+        tys = [el.type for el in elems]
+        if len(tys) == 0:
+            raise ValueError("need at least one element")
+        ty = tys[0]
+        for other in tys:
+            if ty != other:
+                raise TypeError("all elements must have the same type")
+        return cls(types.ArrayType(ty, len(elems)), elems)
+
+    @classmethod
+    def literal_struct(cls, elems):
+        """
+        Construct a literal structure constant made of the given members.
+        """
+        tys = [el.type for el in elems]
+        return cls(types.LiteralStructType(tys), elems)
+
+    @property
+    def addrspace(self):
+        if not isinstance(self.type, types.PointerType):
+            raise TypeError("Only pointer constant have address spaces")
+        return self.type.addrspace
+
+    def __eq__(self, other):
+        if isinstance(other, Constant):
+            return str(self) == str(other)
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __repr__(self):
+        return "<ir.Constant type='%s' value=%r>" % (self.type, self.constant)
+
+
+class FormattedConstant(Constant):
+    """
+    A constant with an already formatted IR representation.
+    """
+
+    def __init__(self, typ, constant):
+        assert isinstance(constant, str)
+        Constant.__init__(self, typ, constant)
+
+    def _to_string(self):
+        return self.constant
+
+    def _get_reference(self):
+        return self.constant
+
+
+class NamedValue(_StrCaching, _StringReferenceCaching, Value):
+    """
+    The base class for named values.
+    """
+    name_prefix = '%'
+    deduplicate_name = True
+
+    def __init__(self, parent, type, name):
+        assert parent is not None
+        assert isinstance(type, types.Type)
+        self.parent = parent
+        self.type = type
+        self._set_name(name)
+
+    def _to_string(self):
+        buf = []
+        if not isinstance(self.type, types.VoidType):
+            buf.append("{0} = ".format(self.get_reference()))
+        self.descr(buf)
+        return "".join(buf).rstrip()
+
+    def descr(self, buf):
+        raise NotImplementedError
+
+    def _get_name(self):
+        return self._name
+
+    def _set_name(self, name):
+        name = self.parent.scope.register(name,
+                                          deduplicate=self.deduplicate_name)
+        self._name = name
+
+    name = property(_get_name, _set_name)
+
+    def _get_reference(self):
+        name = self.name
+        # Quote and escape value name
+        if '\\' in name or '"' in name:
+            name = name.replace('\\', '\\5c').replace('"', '\\22')
+        return '{0}"{1}"'.format(self.name_prefix, name)
+
+    def __repr__(self):
+        return "<ir.%s %r of type '%s'>" % (
+            self.__class__.__name__, self.name, self.type)
+
+    @property
+    def function_type(self):
+        ty = self.type
+        if isinstance(ty, types.PointerType):
+            ty = self.type.pointee
+        if isinstance(ty, types.FunctionType):
+            return ty
+        else:
+            raise TypeError("Not a function: {0}".format(self.type))
+
+
+class MetaDataString(NamedValue):
+    """
+    A metadata string, i.e. a constant string used as a value in a metadata
+    node.
+    """
+
+    def __init__(self, parent, string):
+        super(MetaDataString, self).__init__(parent,
+                                             types.MetaDataType(),
+                                             name="")
+        self.string = string
+
+    def descr(self, buf):
+        buf += (self.get_reference(), "\n")
+
+    def _get_reference(self):
+        return '!"{0}"'.format(_escape_string(self.string))
+
+    _to_string = _get_reference
+
+    def __eq__(self, other):
+        if isinstance(other, MetaDataString):
+            return self.string == other.string
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self.string)
+
+
+class MetaDataArgument(_StrCaching, _StringReferenceCaching, Value):
+    """
+    An argument value to a function taking metadata arguments.
+    This can wrap any other kind of LLVM value.
+
+    Do not instantiate directly, Builder.call() will create these
+    automatically.
+    """
+
+    def __init__(self, value):
+        assert isinstance(value, Value)
+        assert not isinstance(value.type, types.MetaDataType)
+        self.type = types.MetaDataType()
+        self.wrapped_value = value
+
+    def _get_reference(self):
+        # e.g. "i32* %2"
+        return "{0} {1}".format(self.wrapped_value.type,
+                                self.wrapped_value.get_reference())
+
+    _to_string = _get_reference
+
+
+class NamedMetaData(object):
+    """
+    A named metadata node.
+
+    Do not instantiate directly, use Module.add_named_metadata() instead.
+    """
+
+    def __init__(self, parent):
+        self.parent = parent
+        self.operands = []
+
+    def add(self, md):
+        self.operands.append(md)
+
+
+class MDValue(NamedValue):
+    """
+    A metadata node's value, consisting of a sequence of elements ("operands").
+
+    Do not instantiate directly, use Module.add_metadata() instead.
+    """
+    name_prefix = '!'
+
+    def __init__(self, parent, values, name):
+        super(MDValue, self).__init__(parent,
+                                      types.MetaDataType(),
+                                      name=name)
+        self.operands = tuple(values)
+        parent.metadata.append(self)
+
+    def descr(self, buf):
+        operands = []
+        for op in self.operands:
+            if isinstance(op.type, types.MetaDataType):
+                if isinstance(op, Constant) and op.constant is None:
+                    operands.append("null")
+                else:
+                    operands.append(op.get_reference())
+            else:
+                operands.append("{0} {1}".format(op.type, op.get_reference()))
+        operands = ', '.join(operands)
+        buf += ("!{{ {0} }}".format(operands), "\n")
+
+    def _get_reference(self):
+        return self.name_prefix + str(self.name)
+
+    def __eq__(self, other):
+        if isinstance(other, MDValue):
+            return self.operands == other.operands
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self.operands)
+
+
+class DIToken:
+    """
+    A debug information enumeration value that should appear bare in
+    the emitted metadata.
+
+    Use this to wrap known constants, e.g. the DW_* enumerations.
+    """
+
+    def __init__(self, value):
+        self.value = value
+
+
+class DIValue(NamedValue):
+    """
+    A debug information descriptor, containing key-value pairs.
+
+    Do not instantiate directly, use Module.add_debug_info() instead.
+    """
+    name_prefix = '!'
+
+    def __init__(self, parent, is_distinct, kind, operands, name):
+        super(DIValue, self).__init__(parent,
+                                      types.MetaDataType(),
+                                      name=name)
+        self.is_distinct = is_distinct
+        self.kind = kind
+        self.operands = tuple(operands)
+        parent.metadata.append(self)
+
+    def descr(self, buf):
+        if self.is_distinct:
+            buf += ("distinct ",)
+        operands = []
+        for key, value in self.operands:
+            if value is None:
+                strvalue = "null"
+            elif value is True:
+                strvalue = "true"
+            elif value is False:
+                strvalue = "false"
+            elif isinstance(value, DIToken):
+                strvalue = value.value
+            elif isinstance(value, str):
+                strvalue = '"{}"'.format(_escape_string(value))
+            elif isinstance(value, int):
+                strvalue = str(value)
+            elif isinstance(value, NamedValue):
+                strvalue = value.get_reference()
+            else:
+                raise TypeError("invalid operand type for debug info: %r"
+                                % (value,))
+            operands.append("{0}: {1}".format(key, strvalue))
+        operands = ', '.join(operands)
+        buf += ("!", self.kind, "(", operands, ")\n")
+
+    def _get_reference(self):
+        return self.name_prefix + str(self.name)
+
+    def __eq__(self, other):
+        if isinstance(other, DIValue):
+            return self.is_distinct == other.is_distinct and \
+                self.kind == other.kind and \
+                self.operands == other.operands
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash((self.is_distinct, self.kind, self.operands))
+
+
+class GlobalValue(NamedValue, _ConstOpMixin, _HasMetadata):
+    """
+    A global value.
+    """
+    name_prefix = '@'
+    deduplicate_name = False
+
+    def __init__(self, *args, **kwargs):
+        super(GlobalValue, self).__init__(*args, **kwargs)
+        self.linkage = ''
+        self.storage_class = ''
+        self.section = ''
+        self.metadata = {}
+
+
+class GlobalVariable(GlobalValue):
+    """
+    A global variable.
+    """
+
+    def __init__(self, module, typ, name, addrspace=0):
+        assert isinstance(typ, types.Type)
+        super(GlobalVariable, self).__init__(module, typ.as_pointer(addrspace),
+                                             name=name)
+        self.value_type = typ
+        self.initializer = None
+        self.unnamed_addr = False
+        self.global_constant = False
+        self.addrspace = addrspace
+        self.align = None
+        self.parent.add_global(self)
+
+    def descr(self, buf):
+        if self.global_constant:
+            kind = 'constant'
+        else:
+            kind = 'global'
+
+        if not self.linkage:
+            # Default to external linkage
+            linkage = 'external' if self.initializer is None else ''
+        else:
+            linkage = self.linkage
+
+        if linkage:
+            buf.append(linkage + " ")
+        if self.storage_class:
+            buf.append(self.storage_class + " ")
+        if self.unnamed_addr:
+            buf.append("unnamed_addr ")
+        if self.addrspace != 0:
+            buf.append('addrspace({0:d}) '.format(self.addrspace))
+
+        buf.append("{kind} {type}" .format(kind=kind, type=self.value_type))
+
+        if self.initializer is not None:
+            if self.initializer.type != self.value_type:
+                raise TypeError("got initializer of type %s "
+                                "for global value type %s"
+                                % (self.initializer.type, self.value_type))
+            buf.append(" " + self.initializer.get_reference())
+        elif linkage not in ('external', 'extern_weak'):
+            # emit 'undef' for non-external linkage GV
+            buf.append(" " + self.value_type(Undefined).get_reference())
+
+        if self.section:
+            buf.append(", section \"%s\"" % (self.section,))
+
+        if self.align is not None:
+            buf.append(", align %d" % (self.align,))
+
+        if self.metadata:
+            buf.append(self._stringify_metadata(leading_comma=True))
+
+        buf.append("\n")
+
+
+class AttributeSet(set):
+    """A set of string attribute.
+    Only accept items listed in *_known*.
+
+    Properties:
+    * Iterate in sorted order
+    """
+    _known = ()
+
+    def __init__(self, args=()):
+        super().__init__()
+        if isinstance(args, str):
+            args = [args]
+        for name in args:
+            self.add(name)
+
+    def _expand(self, name, typ):
+        return name
+
+    def add(self, name):
+        if name not in self._known:
+            raise ValueError('unknown attr {!r} for {}'.format(name, self))
+        return super(AttributeSet, self).add(name)
+
+    def _to_list(self, typ):
+        return [self._expand(i, typ) for i in sorted(self)]
+
+
+class FunctionAttributes(AttributeSet):
+    _known = frozenset([
+        'argmemonly', 'alwaysinline', 'builtin', 'cold', 'convergent',
+        'inaccessiblememonly', 'inaccessiblemem_or_argmemonly', 'inlinehint',
+        'jumptable', 'minsize', 'naked', 'nobuiltin', 'noduplicate',
+        'noimplicitfloat', 'noinline', 'nonlazybind', 'norecurse',
+        'noredzone', 'noreturn', 'nounwind', 'optnone', 'optsize',
+        'readnone', 'readonly', 'returns_twice', 'sanitize_address',
+        'sanitize_memory', 'sanitize_thread', 'ssp',
+        'sspreg', 'sspstrong', 'uwtable'])
+
+    def __init__(self, args=()):
+        self._alignstack = 0
+        self._personality = None
+        super(FunctionAttributes, self).__init__(args)
+
+    def add(self, name):
+        if ((name == 'alwaysinline' and 'noinline' in self) or
+                (name == 'noinline' and 'alwaysinline' in self)):
+            raise ValueError("Can't have alwaysinline and noinline")
+
+        super().add(name)
+
+    @property
+    def alignstack(self):
+        return self._alignstack
+
+    @alignstack.setter
+    def alignstack(self, val):
+        assert val >= 0
+        self._alignstack = val
+
+    @property
+    def personality(self):
+        return self._personality
+
+    @personality.setter
+    def personality(self, val):
+        assert val is None or isinstance(val, GlobalValue)
+        self._personality = val
+
+    def _to_list(self, ret_type):
+        attrs = super()._to_list(ret_type)
+        if self.alignstack:
+            attrs.append('alignstack({0:d})'.format(self.alignstack))
+        if self.personality:
+            attrs.append('personality {persty} {persfn}'.format(
+                persty=self.personality.type,
+                persfn=self.personality.get_reference()))
+        return attrs
+
+
+class Function(GlobalValue):
+    """Represent a LLVM Function but does uses a Module as parent.
+    Global Values are stored as a set of dependencies (attribute `depends`).
+    """
+
+    def __init__(self, module, ftype, name):
+        assert isinstance(ftype, types.Type)
+        super(Function, self).__init__(module, ftype.as_pointer(), name=name)
+        self.ftype = ftype
+        self.scope = _utils.NameScope()
+        self.blocks = []
+        self.attributes = FunctionAttributes()
+        self.args = tuple([Argument(self, t)
+                           for t in ftype.args])
+        self.return_value = ReturnValue(self, ftype.return_type)
+        self.parent.add_global(self)
+        self.calling_convention = ''
+
+    @property
+    def module(self):
+        return self.parent
+
+    @property
+    def entry_basic_block(self):
+        return self.blocks[0]
+
+    @property
+    def basic_blocks(self):
+        return self.blocks
+
+    def append_basic_block(self, name=''):
+        blk = Block(parent=self, name=name)
+        self.blocks.append(blk)
+        return blk
+
+    def insert_basic_block(self, before, name=''):
+        """Insert block before
+        """
+        blk = Block(parent=self, name=name)
+        self.blocks.insert(before, blk)
+        return blk
+
+    def descr_prototype(self, buf):
+        """
+        Describe the prototype ("head") of the function.
+        """
+        state = "define" if self.blocks else "declare"
+        ret = self.return_value
+        args = ", ".join(str(a) for a in self.args)
+        name = self.get_reference()
+        attrs = ' ' + ' '.join(self.attributes._to_list(
+            self.ftype.return_type)) if self.attributes else ''
+        if any(self.args):
+            vararg = ', ...' if self.ftype.var_arg else ''
+        else:
+            vararg = '...' if self.ftype.var_arg else ''
+        linkage = self.linkage
+        cconv = self.calling_convention
+        prefix = " ".join(str(x) for x in [state, linkage, cconv, ret] if x)
+        metadata = self._stringify_metadata()
+        metadata = ' {}'.format(metadata) if metadata else ''
+        section = ' section "{}"'.format(self.section) if self.section else ''
+        pt_str = "{prefix} {name}({args}{vararg}){attrs}{section}{metadata}\n"
+        prototype = pt_str.format(prefix=prefix, name=name, args=args,
+                                  vararg=vararg, attrs=attrs, section=section,
+                                  metadata=metadata)
+        buf.append(prototype)
+
+    def descr_body(self, buf):
+        """
+        Describe of the body of the function.
+        """
+        for blk in self.blocks:
+            blk.descr(buf)
+
+    def descr(self, buf):
+        self.descr_prototype(buf)
+        if self.blocks:
+            buf.append("{\n")
+            self.descr_body(buf)
+            buf.append("}\n")
+
+    def __str__(self):
+        buf = []
+        self.descr(buf)
+        return "".join(buf)
+
+    @property
+    def is_declaration(self):
+        return len(self.blocks) == 0
+
+
+class ArgumentAttributes(AttributeSet):
+    # List from
+    # https://releases.llvm.org/14.0.0/docs/LangRef.html#parameter-attributes
+    _known = MappingProxyType({
+        # True (emit type),
+        # False (emit name only)
+        'byref': True,
+        'byval': True,
+        'elementtype': True,
+        'immarg': False,
+        'inalloca': True,
+        'inreg': False,
+        'nest': False,
+        'noalias': False,
+        'nocapture': False,
+        'nofree': False,
+        'nonnull': False,
+        'noundef': False,
+        'preallocated': True,
+        'returned': False,
+        'signext': False,
+        'sret': True,
+        'swiftasync': False,
+        'swifterror': False,
+        'swiftself': False,
+        'zeroext': False,
+    })
+
+    def __init__(self, args=()):
+        self._align = 0
+        self._dereferenceable = 0
+        self._dereferenceable_or_null = 0
+        super(ArgumentAttributes, self).__init__(args)
+
+    def _expand(self, name, typ):
+        requires_type = self._known.get(name)
+        if requires_type:
+            return f"{name}({typ.pointee})"
+        else:
+            return name
+
+    @property
+    def align(self):
+        return self._align
+
+    @align.setter
+    def align(self, val):
+        assert isinstance(val, int) and val >= 0
+        self._align = val
+
+    @property
+    def dereferenceable(self):
+        return self._dereferenceable
+
+    @dereferenceable.setter
+    def dereferenceable(self, val):
+        assert isinstance(val, int) and val >= 0
+        self._dereferenceable = val
+
+    @property
+    def dereferenceable_or_null(self):
+        return self._dereferenceable_or_null
+
+    @dereferenceable_or_null.setter
+    def dereferenceable_or_null(self, val):
+        assert isinstance(val, int) and val >= 0
+        self._dereferenceable_or_null = val
+
+    def _to_list(self, typ):
+        attrs = super()._to_list(typ)
+        if self.align:
+            attrs.append('align {0:d}'.format(self.align))
+        if self.dereferenceable:
+            attrs.append('dereferenceable({0:d})'.format(self.dereferenceable))
+        if self.dereferenceable_or_null:
+            dref = 'dereferenceable_or_null({0:d})'
+            attrs.append(dref.format(self.dereferenceable_or_null))
+        return attrs
+
+
+class _BaseArgument(NamedValue):
+    def __init__(self, parent, typ, name=''):
+        assert isinstance(typ, types.Type)
+        super(_BaseArgument, self).__init__(parent, typ, name=name)
+        self.parent = parent
+        self.attributes = ArgumentAttributes()
+
+    def __repr__(self):
+        return "<ir.%s %r of type %s>" % (self.__class__.__name__, self.name,
+                                          self.type)
+
+    def add_attribute(self, attr):
+        self.attributes.add(attr)
+
+
+class Argument(_BaseArgument):
+    """
+    The specification of a function argument.
+    """
+
+    def __str__(self):
+        attrs = self.attributes._to_list(self.type)
+        if attrs:
+            return "{0} {1} {2}".format(self.type, ' '.join(attrs),
+                                        self.get_reference())
+        else:
+            return "{0} {1}".format(self.type, self.get_reference())
+
+
+class ReturnValue(_BaseArgument):
+    """
+    The specification of a function's return value.
+    """
+
+    def __str__(self):
+        attrs = self.attributes._to_list(self.type)
+        if attrs:
+            return "{0} {1}".format(' '.join(attrs), self.type)
+        else:
+            return str(self.type)
+
+
+class Block(NamedValue):
+    """
+    A LLVM IR basic block. A basic block is a sequence of
+    instructions whose execution always goes from start to end.  That
+    is, a control flow instruction (branch) can only appear as the
+    last instruction, and incoming branches can only jump to the first
+    instruction.
+    """
+
+    def __init__(self, parent, name=''):
+        super(Block, self).__init__(parent, types.LabelType(), name=name)
+        self.scope = parent.scope
+        self.instructions = []
+        self.terminator = None
+
+    @property
+    def is_terminated(self):
+        return self.terminator is not None
+
+    @property
+    def function(self):
+        return self.parent
+
+    @property
+    def module(self):
+        return self.parent.module
+
+    def descr(self, buf):
+        buf.append("{0}:\n".format(self._format_name()))
+        buf += ["  {0}\n".format(instr) for instr in self.instructions]
+
+    def replace(self, old, new):
+        """Replace an instruction"""
+        if old.type != new.type:
+            raise TypeError("new instruction has a different type")
+        pos = self.instructions.index(old)
+        self.instructions.remove(old)
+        self.instructions.insert(pos, new)
+
+        for bb in self.parent.basic_blocks:
+            for instr in bb.instructions:
+                instr.replace_usage(old, new)
+
+    def _format_name(self):
+        # Per the LLVM Language Ref on identifiers, names matching the following
+        # regex do not need to be quoted: [%@][-a-zA-Z$._][-a-zA-Z$._0-9]*
+        # Otherwise, the identifier must be quoted and escaped.
+        name = self.name
+        if not _SIMPLE_IDENTIFIER_RE.match(name):
+            name = name.replace('\\', '\\5c').replace('"', '\\22')
+            name = '"{0}"'.format(name)
+        return name
+
+
+class BlockAddress(Value):
+    """
+    The address of a basic block.
+    """
+
+    def __init__(self, function, basic_block):
+        assert isinstance(function, Function)
+        assert isinstance(basic_block, Block)
+        self.type = types.IntType(8).as_pointer()
+        self.function = function
+        self.basic_block = basic_block
+
+    def __str__(self):
+        return '{0} {1}'.format(self.type, self.get_reference())
+
+    def get_reference(self):
+        return "blockaddress({0}, {1})".format(
+            self.function.get_reference(),
+            self.basic_block.get_reference())

vllm/lib/python3.10/site-packages/llvmlite/tests/refprune_proto.py

@@ -0,0 +1,329 @@
+"""
+Contains tests and a prototype implementation for the fanout algorithm in
+the LLVM refprune pass.
+"""
+
+try:
+    from graphviz import Digraph
+except ImportError:
+    pass
+from collections import defaultdict
+
+# The entry block. It's always the same.
+ENTRY = "A"
+
+
+# The following caseNN() functions returns a 3-tuple of
+# (nodes, edges, expected).
+# `nodes` maps BB nodes to incref/decref inside the block.
+# `edges` maps BB nodes to their successor BB.
+# `expected` maps BB-node with incref to a set of BB-nodes with the decrefs, or
+#            the value can be None, indicating invalid prune.
+
+def case1():
+    edges = {
+        "A": ["B"],
+        "B": ["C", "D"],
+        "C": [],
+        "D": ["E", "F"],
+        "E": ["G"],
+        "F": [],
+        "G": ["H", "I"],
+        "I": ["G", "F"],
+        "H": ["J", "K"],
+        "J": ["L", "M"],
+        "K": [],
+        "L": ["Z"],
+        "M": ["Z", "O", "P"],
+        "O": ["Z"],
+        "P": ["Z"],
+        "Z": [],
+    }
+    nodes = defaultdict(list)
+    nodes["D"] = ["incref"]
+    nodes["H"] = ["decref"]
+    nodes["F"] = ["decref", "decref"]
+    expected = {"D": {"H", "F"}}
+    return nodes, edges, expected
+
+
+def case2():
+    edges = {
+        "A": ["B", "C"],
+        "B": ["C"],
+        "C": [],
+    }
+    nodes = defaultdict(list)
+    nodes["A"] = ["incref"]
+    nodes["B"] = ["decref"]
+    nodes["C"] = ["decref"]
+    expected = {"A": None}
+    return nodes, edges, expected
+
+
+def case3():
+    nodes, edges, _ = case1()
+    # adds an invalid edge
+    edges["H"].append("F")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case4():
+    nodes, edges, _ = case1()
+    # adds an invalid edge
+    edges["H"].append("E")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case5():
+    nodes, edges, _ = case1()
+    # adds backedge to go before incref
+    edges["B"].append("I")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case6():
+    nodes, edges, _ = case1()
+    # adds backedge to go before incref
+    edges["I"].append("B")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case7():
+    nodes, edges, _ = case1()
+    # adds forward jump outside
+    edges["I"].append("M")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case8():
+    edges = {
+        "A": ["B", "C"],
+        "B": ["C"],
+        "C": [],
+    }
+    nodes = defaultdict(list)
+    nodes["A"] = ["incref"]
+    nodes["C"] = ["decref"]
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case9():
+    nodes, edges, _ = case8()
+    # adds back edge
+    edges["C"].append("B")
+    expected = {"A": None}
+    return nodes, edges, expected
+
+
+def case10():
+    nodes, edges, _ = case8()
+    # adds back edge to A
+    edges["C"].append("A")
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case11():
+    nodes, edges, _ = case8()
+    edges["C"].append("D")
+    edges["D"] = []
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case12():
+    nodes, edges, _ = case8()
+    edges["C"].append("D")
+    edges["D"] = ["A"]
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case13():
+    nodes, edges, _ = case8()
+    edges["C"].append("D")
+    edges["D"] = ["B"]
+    expected = {"A": None}
+    return nodes, edges, expected
+
+
+def make_predecessor_map(edges):
+    d = defaultdict(set)
+    for src, outgoings in edges.items():
+        for dst in outgoings:
+            d[dst].add(src)
+    return d
+
+
+class FanoutAlgorithm:
+    def __init__(self, nodes, edges, verbose=False):
+        self.nodes = nodes
+        self.edges = edges
+        self.rev_edges = make_predecessor_map(edges)
+        self.print = print if verbose else self._null_print
+
+    def run(self):
+        return self.find_fanout_in_function()
+
+    def _null_print(self, *args, **kwargs):
+        pass
+
+    def find_fanout_in_function(self):
+        got = {}
+        for cur_node in self.edges:
+            for incref in (x for x in self.nodes[cur_node] if x == "incref"):
+                decref_blocks = self.find_fanout(cur_node)
+                self.print(">>", cur_node, "===", decref_blocks)
+                got[cur_node] = decref_blocks
+        return got
+
+    def find_fanout(self, head_node):
+        decref_blocks = self.find_decref_candidates(head_node)
+        self.print("candidates", decref_blocks)
+        if not decref_blocks:
+            return None
+        if not self.verify_non_overlapping(
+            head_node, decref_blocks, entry=ENTRY
+        ):
+            return None
+        return set(decref_blocks)
+
+    def verify_non_overlapping(self, head_node, decref_blocks, entry):
+        self.print("verify_non_overlapping".center(80, "-"))
+        # reverse walk for each decref_blocks
+        # they should end at head_node
+        todo = list(decref_blocks)
+        while todo:
+            cur_node = todo.pop()
+            visited = set()
+
+            workstack = [cur_node]
+            del cur_node
+            while workstack:
+                cur_node = workstack.pop()
+                self.print("cur_node", cur_node, "|", workstack)
+                if cur_node in visited:
+                    continue  # skip
+                if cur_node == entry:
+                    # Entry node
+                    self.print(
+                        "!! failed because we arrived at entry", cur_node
+                    )
+                    return False
+                visited.add(cur_node)
+                # check all predecessors
+                self.print(
+                    f"   {cur_node} preds {self.get_predecessors(cur_node)}"
+                )
+                for pred in self.get_predecessors(cur_node):
+                    if pred in decref_blocks:
+                        # reject because there's a predecessor in decref_blocks
+                        self.print(
+                            "!! reject because predecessor in decref_blocks"
+                        )
+                        return False
+                    if pred != head_node:
+
+                        workstack.append(pred)
+
+        return True
+
+    def get_successors(self, node):
+        return tuple(self.edges[node])
+
+    def get_predecessors(self, node):
+        return tuple(self.rev_edges[node])
+
+    def has_decref(self, node):
+        return "decref" in self.nodes[node]
+
+    def walk_child_for_decref(
+        self, cur_node, path_stack, decref_blocks, depth=10
+    ):
+        indent = " " * len(path_stack)
+        self.print(indent, "walk", path_stack, cur_node)
+        if depth <= 0:
+            return False  # missing
+        if cur_node in path_stack:
+            if cur_node == path_stack[0]:
+                return False  # reject interior node backedge
+            return True  # skip
+        if self.has_decref(cur_node):
+            decref_blocks.add(cur_node)
+            self.print(indent, "found decref")
+            return True
+
+        depth -= 1
+        path_stack += (cur_node,)
+        found = False
+        for child in self.get_successors(cur_node):
+            if not self.walk_child_for_decref(
+                child, path_stack, decref_blocks
+            ):
+                found = False
+                break
+            else:
+                found = True
+
+        self.print(indent, f"ret {found}")
+        return found
+
+    def find_decref_candidates(self, cur_node):
+        # Forward pass
+        self.print("find_decref_candidates".center(80, "-"))
+        path_stack = (cur_node,)
+        found = False
+        decref_blocks = set()
+        for child in self.get_successors(cur_node):
+            if not self.walk_child_for_decref(
+                child, path_stack, decref_blocks
+            ):
+                found = False
+                break
+            else:
+                found = True
+        if not found:
+            return set()
+        else:
+            return decref_blocks
+
+
+def check_once():
+    nodes, edges, expected = case13()
+
+    # Render graph
+    G = Digraph()
+    for node in edges:
+        G.node(node, shape="rect", label=f"{node}\n" + r"\l".join(nodes[node]))
+    for node, children in edges.items():
+        for child in children:
+            G.edge(node, child)
+
+    G.view()
+
+    algo = FanoutAlgorithm(nodes, edges, verbose=True)
+    got = algo.run()
+    assert expected == got
+
+
+def check_all():
+    for k, fn in list(globals().items()):
+        if k.startswith("case"):
+            print(f"{fn}".center(80, "-"))
+            nodes, edges, expected = fn()
+            algo = FanoutAlgorithm(nodes, edges)
+            got = algo.run()
+            assert expected == got
+    print("ALL PASSED")
+
+
+if __name__ == "__main__":
+    # check_once()
+    check_all()

vllm/lib/python3.10/site-packages/llvmlite/tests/test_binding.py

@@ -0,0 +1,2585 @@
+import ctypes
+import threading
+from ctypes import CFUNCTYPE, c_int, c_int32
+from ctypes.util import find_library
+import gc
+import locale
+import os
+import platform
+import re
+import subprocess
+import sys
+import unittest
+from contextlib import contextmanager
+from tempfile import mkstemp
+
+from llvmlite import ir
+from llvmlite import binding as llvm
+from llvmlite.binding import ffi
+from llvmlite.tests import TestCase
+
+llvm_version_major = llvm.llvm_version_info[0]
+
+# arvm7l needs extra ABI symbols to link successfully
+if platform.machine() == 'armv7l':
+    llvm.load_library_permanently('libgcc_s.so.1')
+
+
+def no_de_locale():
+    cur = locale.setlocale(locale.LC_ALL)
+    try:
+        locale.setlocale(locale.LC_ALL, 'de_DE')
+    except locale.Error:
+        return True
+    else:
+        return False
+    finally:
+        locale.setlocale(locale.LC_ALL, cur)
+
+
+asm_sum = r"""
+    ; ModuleID = '<string>'
+    source_filename = "asm_sum.c"
+    target triple = "{triple}"
+    %struct.glob_type = type {{ i64, [2 x i64]}}
+    %struct.glob_type_vec = type {{ i64, <2 x i64>}}
+
+    @glob = global i32 0
+    @glob_b = global i8 0
+    @glob_f = global float 1.5
+    @glob_struct = global %struct.glob_type {{i64 0, [2 x i64] [i64 0, i64 0]}}
+
+    define i32 @sum(i32 %.1, i32 %.2) {{
+      %.3 = add i32 %.1, %.2
+      %.4 = add i32 0, %.3
+      ret i32 %.4
+    }}
+    """
+
+asm_sum2 = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i32 @sum(i32 %.1, i32 %.2) {{
+      %.3 = add i32 %.1, %.2
+      ret i32 %.3
+    }}
+    """
+
+asm_sum3 = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i64 @sum(i64 %.1, i64 %.2) {{
+      %.3 = add i64 %.1, %.2
+      %.4 = add i64 5, %.3
+      %.5 = add i64 -5, %.4
+      ret i64 %.5
+    }}
+    """
+
+asm_mul = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+    @mul_glob = global i32 0
+
+    define i32 @mul(i32 %.1, i32 %.2) {{
+      %.3 = mul i32 %.1, %.2
+      ret i32 %.3
+    }}
+    """
+
+asm_square_sum = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+    @mul_glob = global i32 0
+
+    declare i32 @sum(i32, i32)
+    define i32 @square_sum(i32 %.1, i32 %.2) {{
+      %.3 = call i32 @sum(i32 %.1, i32 %.2)
+      %.4 = mul i32 %.3, %.3
+      ret i32 %.4
+    }}
+    """
+
+asm_getversion = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    declare i8* @Py_GetVersion()
+
+    define void @getversion(i32 %.1, i32 %.2) {{
+      %1 = call i8* @Py_GetVersion()
+      ret void
+    }}
+    """
+
+if platform.python_implementation() == 'PyPy':
+    asm_getversion = asm_getversion.replace('Py_GetVersion', 'PyPy_GetVersion')
+
+# `fadd` used on integer inputs
+asm_parse_error = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i32 @sum(i32 %.1, i32 %.2) {{
+      %.3 = fadd i32 %.1, %.2
+      ret i32 %.3
+    }}
+    """
+
+# "%.bug" definition references itself
+asm_verification_fail = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @sum() {{
+      %.bug = add i32 1, %.bug
+      ret void
+    }}
+    """
+
+asm_sum_declare = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    declare i32 @sum(i32 %.1, i32 %.2)
+    """
+
+asm_vararg_declare = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    declare i32 @vararg(i32 %.1, ...)
+    """
+
+asm_double_inaccurate = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo() {{
+      %const = fadd fp128 0xLF3CB1CCF26FBC178452FB4EC7F91DEAD, 0xL00000000000000000000000000000001
+      ret void
+    }}
+    """  # noqa E501
+
+asm_double_locale = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo() {{
+      %const = fadd double 0.0, 3.14
+      ret void
+    }}
+    """
+
+
+asm_inlineasm = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo() {{
+      call void asm sideeffect "nop", ""()
+      ret void
+    }}
+    """
+
+asm_inlineasm2 = """
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @inlineme() {{
+        ret void
+    }}
+
+    define i32 @caller(i32 %.1, i32 %.2) {{
+    entry:
+      %stack = alloca i32
+      store i32 %.1, i32* %stack
+      br label %main
+    main:
+      %loaded = load i32, i32* %stack
+      %.3 = add i32 %loaded, %.2
+      %.4 = add i32 0, %.3
+      call void @inlineme()
+      ret i32 %.4
+    }}
+"""
+
+asm_inlineasm3 = """
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target triple = "{triple}"
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define void @inlineme() noinline !dbg !15 {{
+  ret void, !dbg !18
+}}
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define i32 @foo(i32 %0, i32 %1) !dbg !19 {{
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !23, metadata !DIExpression()), !dbg !24
+  store i32 %1, i32* %4, align 4
+  call void @llvm.dbg.declare(metadata i32* %4, metadata !25, metadata !DIExpression()), !dbg !26
+  call void @inlineme(), !dbg !27
+  %5 = load i32, i32* %3, align 4, !dbg !28
+  %6 = load i32, i32* %4, align 4, !dbg !29
+  %7 = add nsw i32 %5, %6, !dbg !30
+  ret i32 %7, !dbg !31
+}}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #1 = {{ nofree nosync nounwind readnone speculatable willreturn }}
+
+!llvm.module.flags = !{{!1, !2, !3, !4, !5, !6, !7, !8, !9, !10}}
+!llvm.dbg.cu = !{{!11}}
+!llvm.ident = !{{!14}}
+
+!0 = !{{i32 2, !"SDK Version", [2 x i32] [i32 12, i32 3]}}
+!1 = !{{i32 7, !"Dwarf Version", i32 4}}
+!2 = !{{i32 2, !"Debug Info Version", i32 3}}
+!3 = !{{i32 1, !"wchar_size", i32 4}}
+!4 = !{{i32 1, !"branch-target-enforcement", i32 0}}
+!5 = !{{i32 1, !"sign-return-address", i32 0}}
+!6 = !{{i32 1, !"sign-return-address-all", i32 0}}
+!7 = !{{i32 1, !"sign-return-address-with-bkey", i32 0}}
+!8 = !{{i32 7, !"PIC Level", i32 2}}
+!9 = !{{i32 7, !"uwtable", i32 1}}
+!10 = !{{i32 7, !"frame-pointer", i32 1}}
+!11 = distinct !DICompileUnit(language: DW_LANG_C99, file: !12, producer: "Apple clang version 13.1.6 (clang-1316.0.21.2.3)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !13, splitDebugInlining: false, nameTableKind: None, sysroot: "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk", sdk: "MacOSX.sdk")
+!12 = !DIFile(filename: "test.c", directory: "/")
+!13 = !{{}}
+!14 = !{{!"Apple clang version 13.1.6 (clang-1316.0.21.2.3)"}}
+!15 = distinct !DISubprogram(name: "inlineme", scope: !12, file: !12, line: 1, type: !16, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !11, retainedNodes: !13)
+!16 = !DISubroutineType(types: !17)
+!17 = !{{null}}
+!18 = !DILocation(line: 1, column: 22, scope: !15)
+!19 = distinct !DISubprogram(name: "foo", scope: !12, file: !12, line: 3, type: !20, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !11, retainedNodes: !13)
+!20 = !DISubroutineType(types: !21)
+!21 = !{{!22, !22, !22}}
+!22 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!23 = !DILocalVariable(name: "a", arg: 1, scope: !19, file: !12, line: 3, type: !22)
+!24 = !DILocation(line: 3, column: 13, scope: !19)
+!25 = !DILocalVariable(name: "b", arg: 2, scope: !19, file: !12, line: 3, type: !22)
+!26 = !DILocation(line: 3, column: 20, scope: !19)
+!27 = !DILocation(line: 4, column: 5, scope: !19)
+!28 = !DILocation(line: 5, column: 12, scope: !19)
+!29 = !DILocation(line: 5, column: 16, scope: !19)
+!30 = !DILocation(line: 5, column: 14, scope: !19)
+!31 = !DILocation(line: 5, column: 5, scope: !19)
+"""  # noqa E501
+
+licm_asm = r"""
+; ModuleID = "<string>"
+target triple = "{triple}"
+
+define double @licm(i32 %0) {{
+  %2 = alloca i32, align 4
+  %3 = alloca double, align 8
+  %4 = alloca i32, align 4
+  %5 = alloca double, align 8
+  store i32 %0, i32* %2, align 4
+  store double 0.000000e+00, double* %3, align 8
+  store i32 0, i32* %4, align 4
+  br label %6
+
+6:                                                ; preds = %14, %1
+  %7 = load i32, i32* %4, align 4
+  %8 = load i32, i32* %2, align 4
+  %9 = icmp slt i32 %7, %8
+  br i1 %9, label %10, label %17
+
+10:                                               ; preds = %6
+  store double 7.000000e+00, double* %5, align 8
+  %11 = load double, double* %5, align 8
+  %12 = load double, double* %3, align 8
+  %13 = fadd double %12, %11
+  store double %13, double* %3, align 8
+  br label %14
+
+14:                                               ; preds = %10
+  %15 = load i32, i32* %4, align 4
+  %16 = add nsw i32 %15, 1
+  store i32 %16, i32* %4, align 4
+  br label %6
+
+17:                                               ; preds = %6
+  %18 = load double, double* %3, align 8
+  ret double %18
+}}
+"""  # noqa E501
+
+asm_global_ctors = r"""
+    ; ModuleID = "<string>"
+    target triple = "{triple}"
+
+    @A = global i32 undef
+
+    define void @ctor_A()
+    {{
+      store i32 10, i32* @A
+      ret void
+    }}
+
+    define void @dtor_A()
+    {{
+      store i32 20, i32* @A
+      ret void
+    }}
+
+    define i32 @foo()
+    {{
+      %.2 = load i32, i32* @A
+      %.3 = add i32 %.2, 2
+      ret i32 %.3
+    }}
+
+    @llvm.global_ctors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @ctor_A, i8* null}}]
+    @llvm.global_dtors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @dtor_A, i8* null}}]
+    """  # noqa E501
+
+asm_ext_ctors = r"""
+    ; ModuleID = "<string>"
+    target triple = "{triple}"
+
+    @A = external global i32
+
+    define void @ctor_A()
+    {{
+      store i32 10, i32* @A
+      ret void
+    }}
+
+    define void @dtor_A()
+    {{
+      store i32 20, i32* @A
+      ret void
+    }}
+
+    define i32 @foo()
+    {{
+      %.2 = load i32, i32* @A
+      %.3 = add i32 %.2, 2
+      ret i32 %.3
+    }}
+
+    @llvm.global_ctors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @ctor_A, i8* null}}]
+    @llvm.global_dtors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @dtor_A, i8* null}}]
+    """  # noqa E501
+
+
+asm_nonalphanum_blocklabel = """; ModuleID = ""
+target triple = "unknown-unknown-unknown"
+target datalayout = ""
+
+define i32 @"foo"()
+{
+"<>!*''#":
+  ret i32 12345
+}
+"""  # noqa W291 # trailing space needed for match later
+
+
+asm_null_constant = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo(i64* %.1) {{
+      ret void
+    }}
+
+    define void @bar() {{
+      call void @foo(i64* null)
+      ret void
+    }}
+"""
+
+
+riscv_asm_ilp32 = [
+    'addi\tsp, sp, -16',
+    'sw\ta1, 8(sp)',
+    'sw\ta2, 12(sp)',
+    'fld\tft0, 8(sp)',
+    'fmv.w.x\tft1, a0',
+    'fcvt.d.s\tft1, ft1',
+    'fadd.d\tft0, ft1, ft0',
+    'fsd\tft0, 8(sp)',
+    'lw\ta0, 8(sp)',
+    'lw\ta1, 12(sp)',
+    'addi\tsp, sp, 16',
+    'ret'
+]
+
+
+riscv_asm_ilp32f = [
+    'addi\tsp, sp, -16',
+    'sw\ta0, 8(sp)',
+    'sw\ta1, 12(sp)',
+    'fld\tft0, 8(sp)',
+    'fcvt.d.s\tft1, fa0',
+    'fadd.d\tft0, ft1, ft0',
+    'fsd\tft0, 8(sp)',
+    'lw\ta0, 8(sp)',
+    'lw\ta1, 12(sp)',
+    'addi\tsp, sp, 16',
+    'ret'
+]
+
+
+riscv_asm_ilp32d = [
+    'fcvt.d.s\tft0, fa0',
+    'fadd.d\tfa0, ft0, fa1',
+    'ret'
+]
+
+
+asm_attributes = r"""
+declare void @a_readonly_func(i8 *) readonly
+
+declare i8* @a_arg0_return_func(i8* returned, i32*)
+"""
+
+
+# This produces the following output from objdump:
+#
+# $ objdump -D 632.elf
+#
+# 632.elf:     file format elf64-x86-64
+#
+#
+# Disassembly of section .text:
+#
+# 0000000000000000 <__arybo>:
+#    0:	48 c1 e2 20          	shl    $0x20,%rdx
+#    4:	48 09 c2             	or     %rax,%rdx
+#    7:	48 89 d0             	mov    %rdx,%rax
+#    a:	48 c1 c0 3d          	rol    $0x3d,%rax
+#    e:	48 31 d0             	xor    %rdx,%rax
+#   11:	48 b9 01 20 00 04 80 	movabs $0x7010008004002001,%rcx
+#   18:	00 10 70
+#   1b:	48 0f af c8          	imul   %rax,%rcx
+
+issue_632_elf = \
+    "7f454c4602010100000000000000000001003e00010000000000000000000000000000" \
+    "0000000000e0000000000000000000000040000000000040000500010048c1e2204809" \
+    "c24889d048c1c03d4831d048b90120000480001070480fafc800000000000000000000" \
+    "0000000000000000000000000000002f0000000400f1ff000000000000000000000000" \
+    "00000000070000001200020000000000000000001f00000000000000002e7465787400" \
+    "5f5f617279626f002e6e6f74652e474e552d737461636b002e737472746162002e7379" \
+    "6d746162003c737472696e673e00000000000000000000000000000000000000000000" \
+    "0000000000000000000000000000000000000000000000000000000000000000000000" \
+    "00000000000000001f0000000300000000000000000000000000000000000000a80000" \
+    "0000000000380000000000000000000000000000000100000000000000000000000000" \
+    "000001000000010000000600000000000000000000000000000040000000000000001f" \
+    "000000000000000000000000000000100000000000000000000000000000000f000000" \
+    "01000000000000000000000000000000000000005f0000000000000000000000000000" \
+    "0000000000000000000100000000000000000000000000000027000000020000000000" \
+    "0000000000000000000000000000600000000000000048000000000000000100000002" \
+    "00000008000000000000001800000000000000"
+
+
+issue_632_text = \
+    "48c1e2204809c24889d048c1c03d4831d048b90120000480001070480fafc8"
+
+
+asm_tli_exp2 = r"""
+; ModuleID = '<lambda>'
+source_filename = "<string>"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+declare float @llvm.exp2.f32(float %casted)
+
+define float @foo(i16 %arg) {
+entry:
+  %casted = sitofp i16 %arg to float
+  %ret = call float @llvm.exp2.f32(float %casted)
+  ret float %ret
+}
+"""  # noqa E501
+
+asm_phi_blocks = r"""
+; ModuleID = '<string>'
+target triple = "{triple}"
+
+define void @foo(i32 %N) {{
+  ; unnamed block for testing
+  %cmp4 = icmp sgt i32 %N, 0
+  br i1 %cmp4, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:
+  ret void
+
+for.body:
+  %i.05 = phi i32 [ %inc, %for.body ], [ 0, %0 ]
+  %inc = add nuw nsw i32 %i.05, 1
+  %exitcond.not = icmp eq i32 %inc, %N
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}}
+"""
+
+
+class BaseTest(TestCase):
+
+    def setUp(self):
+        llvm.initialize()
+        llvm.initialize_native_target()
+        llvm.initialize_native_asmprinter()
+        gc.collect()
+        self.old_garbage = gc.garbage[:]
+        gc.garbage[:] = []
+
+    def tearDown(self):
+        # Test that no uncollectable objects were created
+        # (llvmlite objects have a __del__ so a reference cycle could
+        # create some).
+        gc.collect()
+        self.assertEqual(gc.garbage, [])
+        # This will probably put any existing garbage in gc.garbage again
+        del self.old_garbage
+
+    def module(self, asm=asm_sum, context=None):
+        asm = asm.format(triple=llvm.get_default_triple())
+        mod = llvm.parse_assembly(asm, context)
+        return mod
+
+    def glob(self, name='glob', mod=None):
+        if mod is None:
+            mod = self.module()
+        return mod.get_global_variable(name)
+
+    def target_machine(self, *, jit):
+        target = llvm.Target.from_default_triple()
+        return target.create_target_machine(jit=jit)
+
+
+class TestDependencies(BaseTest):
+    """
+    Test DLL dependencies are within a certain expected set.
+    """
+
+    @unittest.skipUnless(sys.platform.startswith('linux'),
+                         "Linux-specific test")
+    @unittest.skipUnless(os.environ.get('LLVMLITE_DIST_TEST'),
+                         "Distribution-specific test")
+    def test_linux(self):
+        lib_path = ffi.lib._name
+        env = os.environ.copy()
+        env['LANG'] = 'C'
+        p = subprocess.Popen(["objdump", "-p", lib_path],
+                             stdout=subprocess.PIPE, env=env)
+        out, _ = p.communicate()
+        self.assertEqual(0, p.returncode)
+        # Parse library dependencies
+        lib_pat = re.compile(r'^([+-_a-zA-Z0-9]+)\.so(?:\.\d+){0,3}$')
+        deps = set()
+        for line in out.decode().splitlines():
+            parts = line.split()
+            if parts and parts[0] == 'NEEDED':
+                dep = parts[1]
+                m = lib_pat.match(dep)
+                if len(parts) != 2 or not m:
+                    self.fail("invalid NEEDED line: %r" % (line,))
+                deps.add(m.group(1))
+        # Sanity check that our dependencies were parsed ok
+        if 'libc' not in deps or 'libpthread' not in deps:
+            self.fail("failed parsing dependencies? got %r" % (deps,))
+        # Ensure all dependencies are expected
+        allowed = set(['librt', 'libdl', 'libpthread', 'libz', 'libm',
+                       'libgcc_s', 'libc', 'ld-linux', 'ld64'])
+        if platform.python_implementation() == 'PyPy':
+            allowed.add('libtinfo')
+
+        for dep in deps:
+            if not dep.startswith('ld-linux-') and dep not in allowed:
+                self.fail("unexpected dependency %r in %r" % (dep, deps))
+
+
+class TestRISCVABI(BaseTest):
+    """
+    Test calling convention of floating point arguments of RISC-V
+    using different ABI.
+    """
+    triple = "riscv32-unknown-linux"
+
+    def setUp(self):
+        super().setUp()
+        llvm.initialize_all_targets()
+        llvm.initialize_all_asmprinters()
+
+    def check_riscv_target(self):
+        try:
+            llvm.Target.from_triple(self.triple)
+        except RuntimeError as e:
+            if "No available targets are compatible with triple" in str(e):
+                self.skipTest("RISCV target unsupported by linked LLVM.")
+            else:
+                raise e
+
+    def riscv_target_machine(self, **kwarg):
+        lltarget = llvm.Target.from_triple(self.triple)
+        return lltarget.create_target_machine(**kwarg)
+
+    def fpadd_ll_module(self):
+        f64 = ir.DoubleType()
+        f32 = ir.FloatType()
+        fnty = ir.FunctionType(f64, (f32, f64))
+        module = ir.Module()
+        func = ir.Function(module, fnty, name="fpadd")
+        block = func.append_basic_block()
+        builder = ir.IRBuilder(block)
+        a, b = func.args
+        arg0 = builder.fpext(a, f64)
+        result = builder.fadd(arg0, b)
+        builder.ret(result)
+
+        llmod = llvm.parse_assembly(str(module))
+        llmod.verify()
+        return llmod
+
+    def break_up_asm(self, asm):
+        asm_list = []
+        for line in asm.splitlines():
+            s_line = line.strip()
+            if not (s_line.startswith(".") or s_line.startswith("fpadd")
+                    or s_line == ""):
+                asm_list.append(s_line)
+        return asm_list
+
+    def test_rv32d_ilp32(self):
+        self.check_riscv_target()
+        llmod = self.fpadd_ll_module()
+        target = self.riscv_target_machine(features="+f,+d", abiname="ilp32")
+        self.assertEqual(self.break_up_asm(target.emit_assembly(llmod)),
+                         riscv_asm_ilp32)
+
+    def test_rv32d_ilp32f(self):
+        self.check_riscv_target()
+        llmod = self.fpadd_ll_module()
+        target = self.riscv_target_machine(features="+f,+d", abiname="ilp32f")
+        self.assertEqual(self.break_up_asm(target.emit_assembly(llmod)),
+                         riscv_asm_ilp32f)
+
+    def test_rv32d_ilp32d(self):
+        self.check_riscv_target()
+        llmod = self.fpadd_ll_module()
+        target = self.riscv_target_machine(features="+f,+d", abiname="ilp32d")
+        self.assertEqual(self.break_up_asm(target.emit_assembly(llmod)),
+                         riscv_asm_ilp32d)
+
+
+class TestMisc(BaseTest):
+    """
+    Test miscellaneous functions in llvm.binding.
+    """
+
+    def test_parse_assembly(self):
+        self.module(asm_sum)
+
+    def test_parse_assembly_error(self):
+        with self.assertRaises(RuntimeError) as cm:
+            self.module(asm_parse_error)
+        s = str(cm.exception)
+        self.assertIn("parsing error", s)
+        self.assertIn("invalid operand type", s)
+
+    def test_nonalphanum_block_name(self):
+        mod = ir.Module()
+        ft = ir.FunctionType(ir.IntType(32), [])
+        fn = ir.Function(mod, ft, "foo")
+        bd = ir.IRBuilder(fn.append_basic_block(name="<>!*''#"))
+        bd.ret(ir.Constant(ir.IntType(32), 12345))
+        asm = str(mod)
+        self.assertEqual(asm, asm_nonalphanum_blocklabel)
+
+    def test_global_context(self):
+        gcontext1 = llvm.context.get_global_context()
+        gcontext2 = llvm.context.get_global_context()
+        assert gcontext1 == gcontext2
+
+    def test_dylib_symbols(self):
+        llvm.add_symbol("__xyzzy", 1234)
+        llvm.add_symbol("__xyzzy", 5678)
+        addr = llvm.address_of_symbol("__xyzzy")
+        self.assertEqual(addr, 5678)
+        addr = llvm.address_of_symbol("__foobar")
+        self.assertIs(addr, None)
+
+    def test_get_default_triple(self):
+        triple = llvm.get_default_triple()
+        self.assertIsInstance(triple, str)
+        self.assertTrue(triple)
+
+    def test_get_process_triple(self):
+        # Sometimes we get synonyms for PPC
+        def normalize_ppc(arch):
+            if arch == 'powerpc64le':
+                return 'ppc64le'
+            else:
+                return arch
+
+        triple = llvm.get_process_triple()
+        default = llvm.get_default_triple()
+        self.assertIsInstance(triple, str)
+        self.assertTrue(triple)
+
+        default_arch = normalize_ppc(default.split('-')[0])
+        triple_arch = normalize_ppc(triple.split('-')[0])
+        # Arch must be equal
+        self.assertEqual(default_arch, triple_arch)
+
+    def test_get_host_cpu_features(self):
+        features = llvm.get_host_cpu_features()
+        # Check the content of `features`
+        self.assertIsInstance(features, dict)
+        self.assertIsInstance(features, llvm.FeatureMap)
+        for k, v in features.items():
+            self.assertIsInstance(k, str)
+            self.assertTrue(k)  # single feature string cannot be empty
+            self.assertIsInstance(v, bool)
+        self.assertIsInstance(features.flatten(), str)
+
+        re_term = r"[+\-][a-zA-Z0-9\._-]+"
+        regex = r"^({0}|{0}(,{0})*)?$".format(re_term)
+        # quick check for our regex
+        self.assertIsNotNone(re.match(regex, ""))
+        self.assertIsNotNone(re.match(regex, "+aa"))
+        self.assertIsNotNone(re.match(regex, "+a,-bb"))
+        # check CpuFeature.flatten()
+        if len(features) == 0:
+            self.assertEqual(features.flatten(), "")
+        else:
+            self.assertIsNotNone(re.match(regex, features.flatten()))
+
+    def test_get_host_cpu_name(self):
+        cpu = llvm.get_host_cpu_name()
+        self.assertIsInstance(cpu, str)
+        self.assertTrue(cpu)
+
+    def test_initfini(self):
+        code = """if 1:
+            from llvmlite import binding as llvm
+
+            llvm.initialize()
+            llvm.initialize_native_target()
+            llvm.initialize_native_asmprinter()
+            llvm.initialize_all_targets()
+            llvm.initialize_all_asmprinters()
+            llvm.shutdown()
+            """
+        subprocess.check_call([sys.executable, "-c", code])
+
+    def test_set_option(self):
+        # We cannot set an option multiple times (LLVM would exit() the
+        # process), so run the code in a subprocess.
+        code = """if 1:
+            from llvmlite import binding as llvm
+
+            llvm.set_option("progname", "-debug-pass=Disabled")
+            """
+        subprocess.check_call([sys.executable, "-c", code])
+
+    def test_version(self):
+        major, minor, patch = llvm.llvm_version_info
+        # one of these can be valid
+        valid = (14, 15)
+        self.assertIn(major, valid)
+        self.assertIn(patch, range(8))
+
+    def test_check_jit_execution(self):
+        llvm.check_jit_execution()
+
+    @unittest.skipIf(no_de_locale(), "Locale not available")
+    def test_print_double_locale(self):
+        m = self.module(asm_double_locale)
+        expect = str(m)
+        # Change the locale so that comma is used as decimal-point
+        # to trigger the LLVM bug (llvmlite issue #80)
+        locale.setlocale(locale.LC_ALL, 'de_DE')
+        # The LLVM bug is trigged by print the module with double constant
+        got = str(m)
+        # Changing the locale should not affect the LLVM IR
+        self.assertEqual(expect, got)
+
+    def test_no_accidental_warnings(self):
+        code = "from llvmlite import binding"
+        flags = "-Werror"
+        cmdargs = [sys.executable, flags, "-c", code]
+        subprocess.check_call(cmdargs)
+
+
+class TestModuleRef(BaseTest):
+
+    def test_str(self):
+        mod = self.module()
+        s = str(mod).strip()
+        self.assertTrue(s.startswith('; ModuleID ='), s)
+
+    def test_close(self):
+        mod = self.module()
+        str(mod)
+        mod.close()
+        with self.assertRaises(ctypes.ArgumentError):
+            str(mod)
+        mod.close()
+
+    def test_with(self):
+        mod = self.module()
+        str(mod)
+        with mod:
+            str(mod)
+        with self.assertRaises(ctypes.ArgumentError):
+            str(mod)
+        with self.assertRaises(RuntimeError):
+            with mod:
+                pass
+
+    def test_name(self):
+        mod = self.module()
+        mod.name = "foo"
+        self.assertEqual(mod.name, "foo")
+        mod.name = "bar"
+        self.assertEqual(mod.name, "bar")
+
+    def test_source_file(self):
+        mod = self.module()
+        self.assertEqual(mod.source_file, "asm_sum.c")
+
+    def test_data_layout(self):
+        mod = self.module()
+        s = mod.data_layout
+        self.assertIsInstance(s, str)
+        mod.data_layout = s
+        self.assertEqual(s, mod.data_layout)
+
+    def test_triple(self):
+        mod = self.module()
+        s = mod.triple
+        self.assertEqual(s, llvm.get_default_triple())
+        mod.triple = ''
+        self.assertEqual(mod.triple, '')
+
+    def test_verify(self):
+        # Verify successful
+        mod = self.module()
+        self.assertIs(mod.verify(), None)
+        # Verify failed
+        mod = self.module(asm_verification_fail)
+        with self.assertRaises(RuntimeError) as cm:
+            mod.verify()
+        s = str(cm.exception)
+        self.assertIn("%.bug = add i32 1, %.bug", s)
+
+    def test_get_function(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        self.assertIsInstance(fn, llvm.ValueRef)
+        self.assertEqual(fn.name, "sum")
+
+        with self.assertRaises(NameError):
+            mod.get_function("foo")
+
+        # Check that fn keeps the module instance alive
+        del mod
+        str(fn.module)
+
+    def test_get_struct_type(self):
+        mod = self.module()
+        st_ty = mod.get_struct_type("struct.glob_type")
+        self.assertEqual(st_ty.name, "struct.glob_type")
+        # also match struct names of form "%struct.glob_type.{some_index}"
+        self.assertIsNotNone(re.match(
+            r'%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }',
+            str(st_ty)))
+
+        with self.assertRaises(NameError):
+            mod.get_struct_type("struct.doesnt_exist")
+
+    def test_get_global_variable(self):
+        mod = self.module()
+        gv = mod.get_global_variable("glob")
+        self.assertIsInstance(gv, llvm.ValueRef)
+        self.assertEqual(gv.name, "glob")
+
+        with self.assertRaises(NameError):
+            mod.get_global_variable("bar")
+
+        # Check that gv keeps the module instance alive
+        del mod
+        str(gv.module)
+
+    def test_global_variables(self):
+        mod = self.module()
+        it = mod.global_variables
+        del mod
+        globs = sorted(it, key=lambda value: value.name)
+        self.assertEqual(len(globs), 4)
+        self.assertEqual([g.name for g in globs],
+                         ["glob", "glob_b", "glob_f", "glob_struct"])
+
+    def test_functions(self):
+        mod = self.module()
+        it = mod.functions
+        del mod
+        funcs = list(it)
+        self.assertEqual(len(funcs), 1)
+        self.assertEqual(funcs[0].name, "sum")
+
+    def test_structs(self):
+        mod = self.module()
+        it = mod.struct_types
+        del mod
+        structs = list(it)
+        self.assertEqual(len(structs), 1)
+        self.assertIsNotNone(re.match(r'struct\.glob_type(\.[\d]+)?',
+                                      structs[0].name))
+        self.assertIsNotNone(re.match(
+            r'%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }',
+            str(structs[0])))
+
+    def test_link_in(self):
+        dest = self.module()
+        src = self.module(asm_mul)
+        dest.link_in(src)
+        self.assertEqual(
+            sorted(f.name for f in dest.functions), ["mul", "sum"])
+        dest.get_function("mul")
+        dest.close()
+        with self.assertRaises(ctypes.ArgumentError):
+            src.get_function("mul")
+
+    def test_link_in_preserve(self):
+        dest = self.module()
+        src2 = self.module(asm_mul)
+        dest.link_in(src2, preserve=True)
+        self.assertEqual(
+            sorted(f.name for f in dest.functions), ["mul", "sum"])
+        dest.close()
+        self.assertEqual(sorted(f.name for f in src2.functions), ["mul"])
+        src2.get_function("mul")
+
+    def test_link_in_error(self):
+        # Raise an error by trying to link two modules with the same global
+        # definition "sum".
+        dest = self.module()
+        src = self.module(asm_sum2)
+        with self.assertRaises(RuntimeError) as cm:
+            dest.link_in(src)
+        self.assertIn("symbol multiply defined", str(cm.exception))
+
+    def test_as_bitcode(self):
+        mod = self.module()
+        bc = mod.as_bitcode()
+        # Refer to http://llvm.org/docs/doxygen/html/ReaderWriter_8h_source.html#l00064  # noqa E501
+        # and http://llvm.org/docs/doxygen/html/ReaderWriter_8h_source.html#l00092  # noqa E501
+        bitcode_wrapper_magic = b'\xde\xc0\x17\x0b'
+        bitcode_magic = b'BC'
+        self.assertTrue(bc.startswith(bitcode_magic) or
+                        bc.startswith(bitcode_wrapper_magic))
+
+    def test_parse_bitcode_error(self):
+        with self.assertRaises(RuntimeError) as cm:
+            llvm.parse_bitcode(b"")
+        self.assertIn("LLVM bitcode parsing error", str(cm.exception))
+        # for llvm < 9
+        if llvm.llvm_version_info[0] < 9:
+            self.assertIn("Invalid bitcode signature", str(cm.exception))
+        else:
+            self.assertIn(
+                "file too small to contain bitcode header", str(cm.exception),
+            )
+
+    def test_bitcode_roundtrip(self):
+        # create a new context to avoid struct renaming
+        context1 = llvm.create_context()
+        bc = self.module(context=context1).as_bitcode()
+        context2 = llvm.create_context()
+        mod = llvm.parse_bitcode(bc, context2)
+        self.assertEqual(mod.as_bitcode(), bc)
+
+        mod.get_function("sum")
+        mod.get_global_variable("glob")
+
+    def test_cloning(self):
+        m = self.module()
+        cloned = m.clone()
+        self.assertIsNot(cloned, m)
+        self.assertEqual(cloned.as_bitcode(), m.as_bitcode())
+
+
+class JITTestMixin(object):
+    """
+    Mixin for ExecutionEngine tests.
+    """
+
+    def get_sum(self, ee, func_name="sum"):
+        ee.finalize_object()
+        cfptr = ee.get_function_address(func_name)
+        self.assertTrue(cfptr)
+        return CFUNCTYPE(c_int, c_int, c_int)(cfptr)
+
+    def test_run_code(self):
+        mod = self.module()
+        with self.jit(mod) as ee:
+            cfunc = self.get_sum(ee)
+            res = cfunc(2, -5)
+            self.assertEqual(-3, res)
+
+    def test_close(self):
+        ee = self.jit(self.module())
+        ee.close()
+        ee.close()
+        with self.assertRaises(ctypes.ArgumentError):
+            ee.finalize_object()
+
+    def test_with(self):
+        ee = self.jit(self.module())
+        with ee:
+            pass
+        with self.assertRaises(RuntimeError):
+            with ee:
+                pass
+        with self.assertRaises(ctypes.ArgumentError):
+            ee.finalize_object()
+
+    def test_module_lifetime(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        ee.close()
+        mod.close()
+
+    def test_module_lifetime2(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        mod.close()
+        ee.close()
+
+    def test_add_module(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        with self.assertRaises(KeyError):
+            ee.add_module(mod)
+        self.assertFalse(mod.closed)
+        ee.close()
+        self.assertTrue(mod.closed)
+
+    def test_add_module_lifetime(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        mod.close()
+        ee.close()
+
+    def test_add_module_lifetime2(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        ee.close()
+        mod.close()
+
+    def test_remove_module(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        ee.remove_module(mod)
+        with self.assertRaises(KeyError):
+            ee.remove_module(mod)
+        self.assertFalse(mod.closed)
+        ee.close()
+        self.assertFalse(mod.closed)
+
+    def test_target_data(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        td = ee.target_data
+        # A singleton is returned
+        self.assertIs(ee.target_data, td)
+        str(td)
+        del mod, ee
+        str(td)
+
+    def test_target_data_abi_enquiries(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        td = ee.target_data
+        gv_i32 = mod.get_global_variable("glob")
+        gv_i8 = mod.get_global_variable("glob_b")
+        gv_struct = mod.get_global_variable("glob_struct")
+        # A global is a pointer, it has the ABI size of a pointer
+        pointer_size = 4 if sys.maxsize < 2 ** 32 else 8
+        for g in (gv_i32, gv_i8, gv_struct):
+            self.assertEqual(td.get_abi_size(g.type), pointer_size)
+
+        self.assertEqual(td.get_pointee_abi_size(gv_i32.type), 4)
+        self.assertEqual(td.get_pointee_abi_alignment(gv_i32.type), 4)
+
+        self.assertEqual(td.get_pointee_abi_size(gv_i8.type), 1)
+        self.assertIn(td.get_pointee_abi_alignment(gv_i8.type), (1, 2, 4))
+
+        self.assertEqual(td.get_pointee_abi_size(gv_struct.type), 24)
+        self.assertIn(td.get_pointee_abi_alignment(gv_struct.type), (4, 8))
+
+    def test_object_cache_notify(self):
+        notifies = []
+
+        def notify(mod, buf):
+            notifies.append((mod, buf))
+
+        mod = self.module()
+        ee = self.jit(mod)
+        ee.set_object_cache(notify)
+
+        self.assertEqual(len(notifies), 0)
+        cfunc = self.get_sum(ee)
+        cfunc(2, -5)
+        self.assertEqual(len(notifies), 1)
+        # The right module object was found
+        self.assertIs(notifies[0][0], mod)
+        self.assertIsInstance(notifies[0][1], bytes)
+
+        notifies[:] = []
+        mod2 = self.module(asm_mul)
+        ee.add_module(mod2)
+        cfunc = self.get_sum(ee, "mul")
+        self.assertEqual(len(notifies), 1)
+        # The right module object was found
+        self.assertIs(notifies[0][0], mod2)
+        self.assertIsInstance(notifies[0][1], bytes)
+
+    def test_object_cache_getbuffer(self):
+        notifies = []
+        getbuffers = []
+
+        def notify(mod, buf):
+            notifies.append((mod, buf))
+
+        def getbuffer(mod):
+            getbuffers.append(mod)
+
+        mod = self.module()
+        ee = self.jit(mod)
+        ee.set_object_cache(notify, getbuffer)
+
+        # First return None from getbuffer(): the object is compiled normally
+        self.assertEqual(len(notifies), 0)
+        self.assertEqual(len(getbuffers), 0)
+        cfunc = self.get_sum(ee)
+        self.assertEqual(len(notifies), 1)
+        self.assertEqual(len(getbuffers), 1)
+        self.assertIs(getbuffers[0], mod)
+        sum_buffer = notifies[0][1]
+
+        # Recreate a new EE, and use getbuffer() to return the previously
+        # compiled object.
+
+        def getbuffer_successful(mod):
+            getbuffers.append(mod)
+            return sum_buffer
+
+        notifies[:] = []
+        getbuffers[:] = []
+        # Use another source module to make sure it is ignored
+        mod = self.module(asm_mul)
+        ee = self.jit(mod)
+        ee.set_object_cache(notify, getbuffer_successful)
+
+        self.assertEqual(len(notifies), 0)
+        self.assertEqual(len(getbuffers), 0)
+        cfunc = self.get_sum(ee)
+        self.assertEqual(cfunc(2, -5), -3)
+        self.assertEqual(len(notifies), 0)
+        self.assertEqual(len(getbuffers), 1)
+
+
+class JITWithTMTestMixin(JITTestMixin):
+
+    def test_emit_assembly(self):
+        """Test TargetMachineRef.emit_assembly()"""
+        target_machine = self.target_machine(jit=True)
+        mod = self.module()
+        ee = self.jit(mod, target_machine)  # noqa F841 # Keeps pointers alive
+        raw_asm = target_machine.emit_assembly(mod)
+        self.assertIn("sum", raw_asm)
+        target_machine.set_asm_verbosity(True)
+        raw_asm_verbose = target_machine.emit_assembly(mod)
+        self.assertIn("sum", raw_asm)
+        self.assertNotEqual(raw_asm, raw_asm_verbose)
+
+    def test_emit_object(self):
+        """Test TargetMachineRef.emit_object()"""
+        target_machine = self.target_machine(jit=True)
+        mod = self.module()
+        ee = self.jit(mod, target_machine)  # noqa F841 # Keeps pointers alive
+        code_object = target_machine.emit_object(mod)
+        self.assertIsInstance(code_object, bytes)
+        if sys.platform.startswith('linux'):
+            # Sanity check
+            self.assertIn(b"ELF", code_object[:10])
+
+
+class TestMCJit(BaseTest, JITWithTMTestMixin):
+    """
+    Test JIT engines created with create_mcjit_compiler().
+    """
+
+    def jit(self, mod, target_machine=None):
+        if target_machine is None:
+            target_machine = self.target_machine(jit=True)
+        return llvm.create_mcjit_compiler(mod, target_machine)
+
+
+# There are some memory corruption issues with OrcJIT on AArch64 - see Issue
+# #1000. Since OrcJIT is experimental, and we don't test regularly during
+# llvmlite development on non-x86 platforms, it seems safest to skip these
+# tests on non-x86 platforms.
+@unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
+class TestOrcLLJIT(BaseTest):
+
+    def jit(self, asm=asm_sum, func_name="sum", target_machine=None,
+            add_process=False, func_type=CFUNCTYPE(c_int, c_int, c_int),
+            suppress_errors=False):
+        lljit = llvm.create_lljit_compiler(target_machine,
+                                           use_jit_link=False,
+                                           suppress_errors=suppress_errors)
+        builder = llvm.JITLibraryBuilder()
+        if add_process:
+            builder.add_current_process()
+        rt = builder\
+            .add_ir(asm.format(triple=llvm.get_default_triple()))\
+            .export_symbol(func_name)\
+            .link(lljit, func_name)
+        cfptr = rt[func_name]
+        self.assertTrue(cfptr)
+        self.assertEqual(func_name, rt.name)
+        return lljit, rt, func_type(cfptr)
+
+    # From test_dylib_symbols
+    def test_define_symbol(self):
+        lljit = llvm.create_lljit_compiler()
+        rt = llvm.JITLibraryBuilder().import_symbol("__xyzzy", 1234)\
+            .export_symbol("__xyzzy").link(lljit, "foo")
+        self.assertEqual(rt["__xyzzy"], 1234)
+
+    def test_lookup_undefined_symbol_fails(self):
+        lljit = llvm.create_lljit_compiler()
+        with self.assertRaisesRegex(RuntimeError, 'No such library'):
+            lljit.lookup("foo", "__foobar")
+        rt = llvm.JITLibraryBuilder().import_symbol("__xyzzy", 1234)\
+            .export_symbol("__xyzzy").link(lljit, "foo")
+        self.assertNotEqual(rt["__xyzzy"], 0)
+        with self.assertRaisesRegex(RuntimeError,
+                                    'Symbols not found.*__foobar'):
+            lljit.lookup("foo", "__foobar")
+
+    def test_jit_link(self):
+        if sys.platform == "win32":
+            with self.assertRaisesRegex(RuntimeError,
+                                        'JITLink .* Windows'):
+                llvm.create_lljit_compiler(use_jit_link=True)
+        else:
+            self.assertIsNotNone(llvm.create_lljit_compiler(use_jit_link=True))
+
+    def test_run_code(self):
+        (lljit, rt, cfunc) = self.jit()
+        with lljit:
+            res = cfunc(2, -5)
+            self.assertEqual(-3, res)
+
+    def test_close(self):
+        (lljit, rt, cfunc) = self.jit()
+        lljit.close()
+        lljit.close()
+        with self.assertRaises(AssertionError):
+            lljit.lookup("foo", "fn")
+
+    def test_with(self):
+        (lljit, rt, cfunc) = self.jit()
+        with lljit:
+            pass
+        with self.assertRaises(RuntimeError):
+            with lljit:
+                pass
+        with self.assertRaises(AssertionError):
+            lljit.lookup("foo", "fn")
+
+    def test_add_ir_module(self):
+        (lljit, rt_sum, cfunc_sum) = self.jit()
+        rt_mul = llvm.JITLibraryBuilder() \
+            .add_ir(asm_mul.format(triple=llvm.get_default_triple())) \
+            .export_symbol("mul") \
+            .link(lljit, "mul")
+        res = CFUNCTYPE(c_int, c_int, c_int)(rt_mul["mul"])(2, -5)
+        self.assertEqual(-10, res)
+        self.assertNotEqual(lljit.lookup("sum", "sum")["sum"], 0)
+        self.assertNotEqual(lljit.lookup("mul", "mul")["mul"], 0)
+        with self.assertRaises(RuntimeError):
+            lljit.lookup("sum", "mul")
+        with self.assertRaises(RuntimeError):
+            lljit.lookup("mul", "sum")
+
+    def test_remove_module(self):
+        (lljit, rt_sum, _) = self.jit()
+        del rt_sum
+        gc.collect()
+        with self.assertRaises(RuntimeError):
+            lljit.lookup("sum", "sum")
+        lljit.close()
+
+    def test_lib_depends(self):
+        (lljit, rt_sum, cfunc_sum) = self.jit()
+        rt_mul = llvm.JITLibraryBuilder() \
+            .add_ir(asm_square_sum.format(triple=llvm.get_default_triple())) \
+            .export_symbol("square_sum") \
+            .add_jit_library("sum") \
+            .link(lljit, "square_sum")
+        res = CFUNCTYPE(c_int, c_int, c_int)(rt_mul["square_sum"])(2, -5)
+        self.assertEqual(9, res)
+
+    def test_target_data(self):
+        (lljit, rt, _) = self.jit()
+        td = lljit.target_data
+        # A singleton is returned
+        self.assertIs(lljit.target_data, td)
+        str(td)
+        del lljit
+        str(td)
+
+    def test_global_ctors_dtors(self):
+        # test issue #303
+        # (https://github.com/numba/llvmlite/issues/303)
+        shared_value = c_int32(0)
+        lljit = llvm.create_lljit_compiler()
+        builder = llvm.JITLibraryBuilder()
+        rt = builder \
+            .add_ir(asm_ext_ctors.format(triple=llvm.get_default_triple())) \
+            .import_symbol("A", ctypes.addressof(shared_value)) \
+            .export_symbol("foo") \
+            .link(lljit, "foo")
+        foo = rt["foo"]
+        self.assertTrue(foo)
+        self.assertEqual(CFUNCTYPE(c_int)(foo)(), 12)
+        del rt
+        self.assertNotEqual(shared_value.value, 20)
+
+    def test_lookup_current_process_symbol_fails(self):
+        # An attempt to lookup a symbol in the current process (Py_GetVersion,
+        # in this case) should fail with an appropriate error if we have not
+        # enabled searching the current process for symbols.
+        msg = 'Failed to materialize symbols:.*getversion'
+        with self.assertRaisesRegex(RuntimeError, msg):
+            self.jit(asm_getversion, "getversion", suppress_errors=True)
+
+    def test_lookup_current_process_symbol(self):
+        self.jit(asm_getversion, "getversion", None, True)
+
+    def test_thread_safe(self):
+        lljit = llvm.create_lljit_compiler()
+        llvm_ir = asm_sum.format(triple=llvm.get_default_triple())
+
+        def compile_many(i):
+            def do_work():
+                tracking = []
+                for c in range(50):
+                    tracking.append(llvm.JITLibraryBuilder()
+                                    .add_ir(llvm_ir)
+                                    .export_symbol("sum")
+                                    .link(lljit, f"sum_{i}_{c}"))
+
+            return do_work
+
+        ths = [threading.Thread(target=compile_many(i))
+               for i in range(os.cpu_count())]
+        for th in ths:
+            th.start()
+        for th in ths:
+            th.join()
+
+    def test_add_object_file(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        lljit = llvm.create_lljit_compiler(target_machine)
+        rt = llvm.JITLibraryBuilder()\
+            .add_object_img(target_machine.emit_object(mod))\
+            .export_symbol("sum")\
+            .link(lljit, "sum")
+        sum = CFUNCTYPE(c_int, c_int, c_int)(rt["sum"])
+        self.assertEqual(sum(2, 3), 5)
+
+    def test_add_object_file_from_filesystem(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        temp_desc, temp_path = mkstemp()
+
+        try:
+            with os.fdopen(temp_desc, "wb") as f:
+                f.write(obj_bin)
+            lljit = llvm.create_lljit_compiler(target_machine)
+            rt = llvm.JITLibraryBuilder() \
+                .add_object_file(temp_path) \
+                .export_symbol("sum") \
+                .link(lljit, "sum")
+            sum = CFUNCTYPE(c_int, c_int, c_int)(rt["sum"])
+            self.assertEqual(sum(2, 3), 5)
+        finally:
+            os.unlink(temp_path)
+
+
+class TestValueRef(BaseTest):
+
+    def test_str(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(str(glob), "@glob = global i32 0")
+
+    def test_name(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(glob.name, "glob")
+        glob.name = "foobar"
+        self.assertEqual(glob.name, "foobar")
+
+    def test_linkage(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        linkage = glob.linkage
+        self.assertIsInstance(glob.linkage, llvm.Linkage)
+        glob.linkage = linkage
+        self.assertEqual(glob.linkage, linkage)
+        for linkage in ("internal", "external"):
+            glob.linkage = linkage
+            self.assertIsInstance(glob.linkage, llvm.Linkage)
+            self.assertEqual(glob.linkage.name, linkage)
+
+    def test_visibility(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        visibility = glob.visibility
+        self.assertIsInstance(glob.visibility, llvm.Visibility)
+        glob.visibility = visibility
+        self.assertEqual(glob.visibility, visibility)
+        for visibility in ("hidden", "protected", "default"):
+            glob.visibility = visibility
+            self.assertIsInstance(glob.visibility, llvm.Visibility)
+            self.assertEqual(glob.visibility.name, visibility)
+
+    def test_storage_class(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        storage_class = glob.storage_class
+        self.assertIsInstance(glob.storage_class, llvm.StorageClass)
+        glob.storage_class = storage_class
+        self.assertEqual(glob.storage_class, storage_class)
+        for storage_class in ("dllimport", "dllexport", "default"):
+            glob.storage_class = storage_class
+            self.assertIsInstance(glob.storage_class, llvm.StorageClass)
+            self.assertEqual(glob.storage_class.name, storage_class)
+
+    def test_add_function_attribute(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        fn.add_function_attribute("nocapture")
+        with self.assertRaises(ValueError) as raises:
+            fn.add_function_attribute("zext")
+        self.assertEqual(str(raises.exception), "no such attribute 'zext'")
+
+    def test_module(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertIs(glob.module, mod)
+
+    def test_type(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        tp = glob.type
+        self.assertIsInstance(tp, llvm.TypeRef)
+
+    def test_type_name(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        tp = glob.type
+        self.assertEqual(tp.name, "")
+        st = mod.get_global_variable("glob_struct")
+        self.assertIsNotNone(re.match(r"struct\.glob_type(\.[\d]+)?",
+                                      st.type.element_type.name))
+
+    def test_type_printing_variable(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        tp = glob.type
+        self.assertEqual(str(tp), 'i32*')
+
+    def test_type_printing_function(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        self.assertEqual(str(fn.type), "i32 (i32, i32)*")
+
+    def test_type_printing_struct(self):
+        mod = self.module()
+        st = mod.get_global_variable("glob_struct")
+        self.assertTrue(st.type.is_pointer)
+        self.assertIsNotNone(re.match(r'%struct\.glob_type(\.[\d]+)?\*',
+                                      str(st.type)))
+        self.assertIsNotNone(re.match(
+            r"%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }",
+            str(st.type.element_type)))
+
+    def test_close(self):
+        glob = self.glob()
+        glob.close()
+        glob.close()
+
+    def test_is_declaration(self):
+        defined = self.module().get_function('sum')
+        declared = self.module(asm_sum_declare).get_function('sum')
+        self.assertFalse(defined.is_declaration)
+        self.assertTrue(declared.is_declaration)
+
+    def test_module_global_variables(self):
+        mod = self.module(asm_sum)
+        gvars = list(mod.global_variables)
+        self.assertEqual(len(gvars), 4)
+        for v in gvars:
+            self.assertTrue(v.is_global)
+
+    def test_module_functions(self):
+        mod = self.module()
+        funcs = list(mod.functions)
+        self.assertEqual(len(funcs), 1)
+        func = funcs[0]
+        self.assertTrue(func.is_function)
+        self.assertEqual(func.name, 'sum')
+
+        with self.assertRaises(ValueError):
+            func.instructions
+        with self.assertRaises(ValueError):
+            func.operands
+        with self.assertRaises(ValueError):
+            func.opcode
+
+    def test_function_arguments(self):
+        mod = self.module()
+        func = mod.get_function('sum')
+        self.assertTrue(func.is_function)
+        args = list(func.arguments)
+        self.assertEqual(len(args), 2)
+        self.assertTrue(args[0].is_argument)
+        self.assertTrue(args[1].is_argument)
+        self.assertEqual(args[0].name, '.1')
+        self.assertEqual(str(args[0].type), 'i32')
+        self.assertEqual(args[1].name, '.2')
+        self.assertEqual(str(args[1].type), 'i32')
+
+        with self.assertRaises(ValueError):
+            args[0].blocks
+        with self.assertRaises(ValueError):
+            args[0].arguments
+
+    def test_function_blocks(self):
+        func = self.module().get_function('sum')
+        blocks = list(func.blocks)
+        self.assertEqual(len(blocks), 1)
+        block = blocks[0]
+        self.assertTrue(block.is_block)
+
+    def test_block_instructions(self):
+        func = self.module().get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(len(insts), 3)
+        self.assertTrue(insts[0].is_instruction)
+        self.assertTrue(insts[1].is_instruction)
+        self.assertTrue(insts[2].is_instruction)
+        self.assertEqual(insts[0].opcode, 'add')
+        self.assertEqual(insts[1].opcode, 'add')
+        self.assertEqual(insts[2].opcode, 'ret')
+
+    def test_instruction_operands(self):
+        func = self.module().get_function('sum')
+        add = list(list(func.blocks)[0].instructions)[0]
+        self.assertEqual(add.opcode, 'add')
+        operands = list(add.operands)
+        self.assertEqual(len(operands), 2)
+        self.assertTrue(operands[0].is_operand)
+        self.assertTrue(operands[1].is_operand)
+        self.assertEqual(operands[0].name, '.1')
+        self.assertEqual(str(operands[0].type), 'i32')
+        self.assertEqual(operands[1].name, '.2')
+        self.assertEqual(str(operands[1].type), 'i32')
+
+    def test_function_attributes(self):
+        mod = self.module(asm_attributes)
+        for func in mod.functions:
+            attrs = list(func.attributes)
+            if func.name == 'a_readonly_func':
+                self.assertEqual(attrs, [b'readonly'])
+            elif func.name == 'a_arg0_return_func':
+                self.assertEqual(attrs, [])
+                args = list(func.arguments)
+                self.assertEqual(list(args[0].attributes), [b'returned'])
+                self.assertEqual(list(args[1].attributes), [])
+
+    def test_value_kind(self):
+        mod = self.module()
+        self.assertEqual(mod.get_global_variable('glob').value_kind,
+                         llvm.ValueKind.global_variable)
+        func = mod.get_function('sum')
+        self.assertEqual(func.value_kind, llvm.ValueKind.function)
+        block = list(func.blocks)[0]
+        self.assertEqual(block.value_kind, llvm.ValueKind.basic_block)
+        inst = list(block.instructions)[1]
+        self.assertEqual(inst.value_kind, llvm.ValueKind.instruction)
+        self.assertEqual(list(inst.operands)[0].value_kind,
+                         llvm.ValueKind.constant_int)
+        self.assertEqual(list(inst.operands)[1].value_kind,
+                         llvm.ValueKind.instruction)
+
+        iasm_func = self.module(asm_inlineasm).get_function('foo')
+        iasm_inst = list(list(iasm_func.blocks)[0].instructions)[0]
+        self.assertEqual(list(iasm_inst.operands)[0].value_kind,
+                         llvm.ValueKind.inline_asm)
+
+    def test_is_constant(self):
+        mod = self.module()
+        self.assertTrue(mod.get_global_variable('glob').is_constant)
+        constant_operands = 0
+        for func in mod.functions:
+            self.assertTrue(func.is_constant)
+            for block in func.blocks:
+                self.assertFalse(block.is_constant)
+                for inst in block.instructions:
+                    self.assertFalse(inst.is_constant)
+                    for op in inst.operands:
+                        if op.is_constant:
+                            constant_operands += 1
+
+        self.assertEqual(constant_operands, 1)
+
+    def test_constant_int(self):
+        mod = self.module()
+        func = mod.get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(insts[1].opcode, 'add')
+        operands = list(insts[1].operands)
+        self.assertTrue(operands[0].is_constant)
+        self.assertFalse(operands[1].is_constant)
+        self.assertEqual(operands[0].get_constant_value(), 0)
+        with self.assertRaises(ValueError):
+            operands[1].get_constant_value()
+
+        mod = self.module(asm_sum3)
+        func = mod.get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        posint64 = list(insts[1].operands)[0]
+        negint64 = list(insts[2].operands)[0]
+        self.assertEqual(posint64.get_constant_value(), 5)
+        self.assertEqual(negint64.get_constant_value(signed_int=True), -5)
+
+        # Convert from unsigned arbitrary-precision integer to signed i64
+        as_u64 = negint64.get_constant_value(signed_int=False)
+        as_i64 = int.from_bytes(as_u64.to_bytes(8, 'little'), 'little',
+                                signed=True)
+        self.assertEqual(as_i64, -5)
+
+    def test_constant_fp(self):
+        mod = self.module(asm_double_locale)
+        func = mod.get_function('foo')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(len(insts), 2)
+        self.assertEqual(insts[0].opcode, 'fadd')
+        operands = list(insts[0].operands)
+        self.assertTrue(operands[0].is_constant)
+        self.assertAlmostEqual(operands[0].get_constant_value(), 0.0)
+        self.assertTrue(operands[1].is_constant)
+        self.assertAlmostEqual(operands[1].get_constant_value(), 3.14)
+
+        mod = self.module(asm_double_inaccurate)
+        func = mod.get_function('foo')
+        inst = list(list(func.blocks)[0].instructions)[0]
+        operands = list(inst.operands)
+        with self.assertRaises(ValueError):
+            operands[0].get_constant_value()
+        self.assertAlmostEqual(operands[1].get_constant_value(round_fp=True), 0)
+
+    def test_constant_as_string(self):
+        mod = self.module(asm_null_constant)
+        func = mod.get_function('bar')
+        inst = list(list(func.blocks)[0].instructions)[0]
+        arg = list(inst.operands)[0]
+        self.assertTrue(arg.is_constant)
+        self.assertEqual(arg.get_constant_value(), 'i64* null')
+
+    def test_incoming_phi_blocks(self):
+        mod = self.module(asm_phi_blocks)
+        func = mod.get_function('foo')
+        blocks = list(func.blocks)
+        instructions = list(blocks[-1].instructions)
+        self.assertTrue(instructions[0].is_instruction)
+        self.assertEqual(instructions[0].opcode, 'phi')
+
+        incoming_blocks = list(instructions[0].incoming_blocks)
+        self.assertEqual(len(incoming_blocks), 2)
+        self.assertTrue(incoming_blocks[0].is_block)
+        self.assertTrue(incoming_blocks[1].is_block)
+        # Test reference to blocks (named or unnamed)
+        self.assertEqual(incoming_blocks[0], blocks[-1])
+        self.assertEqual(incoming_blocks[1], blocks[0])
+
+        # Test case that should fail
+        self.assertNotEqual(instructions[1].opcode, 'phi')
+        with self.assertRaises(ValueError):
+            instructions[1].incoming_blocks
+
+
+class TestTypeRef(BaseTest):
+
+    def test_str(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(str(glob.type), "i32*")
+        glob_struct_type = mod.get_struct_type("struct.glob_type")
+        self.assertEqual(str(glob_struct_type),
+                         "%struct.glob_type = type { i64, [2 x i64] }")
+
+        elements = list(glob_struct_type.elements)
+        self.assertEqual(len(elements), 2)
+        self.assertEqual(str(elements[0]), "i64")
+        self.assertEqual(str(elements[1]), "[2 x i64]")
+
+    def test_type_kind(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(glob.type.type_kind, llvm.TypeKind.pointer)
+        self.assertTrue(glob.type.is_pointer)
+
+        glob_struct = mod.get_global_variable("glob_struct")
+        self.assertEqual(glob_struct.type.type_kind, llvm.TypeKind.pointer)
+        self.assertTrue(glob_struct.type.is_pointer)
+
+        stype = next(iter(glob_struct.type.elements))
+        self.assertEqual(stype.type_kind, llvm.TypeKind.struct)
+        self.assertTrue(stype.is_struct)
+
+        stype_a, stype_b = stype.elements
+        self.assertEqual(stype_a.type_kind, llvm.TypeKind.integer)
+        self.assertEqual(stype_b.type_kind, llvm.TypeKind.array)
+        self.assertTrue(stype_b.is_array)
+
+        glob_vec_struct_type = mod.get_struct_type("struct.glob_type_vec")
+        _, vector_type = glob_vec_struct_type.elements
+        self.assertEqual(vector_type.type_kind, llvm.TypeKind.vector)
+        self.assertTrue(vector_type.is_vector)
+
+        funcptr = mod.get_function("sum").type
+        self.assertEqual(funcptr.type_kind, llvm.TypeKind.pointer)
+        functype, = funcptr.elements
+        self.assertEqual(functype.type_kind, llvm.TypeKind.function)
+
+    def test_element_count(self):
+        mod = self.module()
+        glob_struct_type = mod.get_struct_type("struct.glob_type")
+        _, array_type = glob_struct_type.elements
+        self.assertEqual(array_type.element_count, 2)
+        with self.assertRaises(ValueError):
+            glob_struct_type.element_count
+
+    def test_type_width(self):
+        mod = self.module()
+        glob_struct_type = mod.get_struct_type("struct.glob_type")
+        glob_vec_struct_type = mod.get_struct_type("struct.glob_type_vec")
+        integer_type, array_type = glob_struct_type.elements
+        _, vector_type = glob_vec_struct_type.elements
+        self.assertEqual(integer_type.type_width, 64)
+        self.assertEqual(vector_type.type_width, 64 * 2)
+
+        # Structs and arrays are not primitive types
+        self.assertEqual(glob_struct_type.type_width, 0)
+        self.assertEqual(array_type.type_width, 0)
+
+    def test_vararg_function(self):
+        # Variadic function
+        mod = self.module(asm_vararg_declare)
+        func = mod.get_function('vararg')
+        decltype = func.type.element_type
+        self.assertTrue(decltype.is_function_vararg)
+
+        mod = self.module(asm_sum_declare)
+        func = mod.get_function('sum')
+        decltype = func.type.element_type
+        self.assertFalse(decltype.is_function_vararg)
+
+        # test that the function pointer type cannot use is_function_vararg
+        self.assertTrue(func.type.is_pointer)
+        with self.assertRaises(ValueError) as raises:
+            func.type.is_function_vararg
+        self.assertIn("Type i32 (i32, i32)* is not a function",
+                      str(raises.exception))
+
+
+class TestTarget(BaseTest):
+
+    def test_from_triple(self):
+        f = llvm.Target.from_triple
+        with self.assertRaises(RuntimeError) as cm:
+            f("foobar")
+        self.assertIn("No available targets are compatible with",
+                      str(cm.exception))
+        triple = llvm.get_default_triple()
+        target = f(triple)
+        self.assertEqual(target.triple, triple)
+        target.close()
+
+    def test_create_target_machine(self):
+        target = llvm.Target.from_triple(llvm.get_default_triple())
+        # With the default settings
+        target.create_target_machine('', '', 1, 'default', 'default')
+        # With the host's CPU
+        cpu = llvm.get_host_cpu_name()
+        target.create_target_machine(cpu, '', 1, 'default', 'default')
+
+    def test_name(self):
+        t = llvm.Target.from_triple(llvm.get_default_triple())
+        u = llvm.Target.from_default_triple()
+        self.assertIsInstance(t.name, str)
+        self.assertEqual(t.name, u.name)
+
+    def test_description(self):
+        t = llvm.Target.from_triple(llvm.get_default_triple())
+        u = llvm.Target.from_default_triple()
+        self.assertIsInstance(t.description, str)
+        self.assertEqual(t.description, u.description)
+
+    def test_str(self):
+        target = llvm.Target.from_triple(llvm.get_default_triple())
+        s = str(target)
+        self.assertIn(target.name, s)
+        self.assertIn(target.description, s)
+
+
+class TestTargetData(BaseTest):
+
+    def target_data(self):
+        return llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
+
+    def test_get_abi_size(self):
+        td = self.target_data()
+        glob = self.glob()
+        self.assertEqual(td.get_abi_size(glob.type), 8)
+
+    def test_get_pointee_abi_size(self):
+        td = self.target_data()
+
+        glob = self.glob()
+        self.assertEqual(td.get_pointee_abi_size(glob.type), 4)
+
+        glob = self.glob("glob_struct")
+        self.assertEqual(td.get_pointee_abi_size(glob.type), 24)
+
+    def test_get_struct_element_offset(self):
+        td = self.target_data()
+        glob = self.glob("glob_struct")
+
+        with self.assertRaises(ValueError):
+            td.get_element_offset(glob.type, 0)
+
+        struct_type = glob.type.element_type
+        self.assertEqual(td.get_element_offset(struct_type, 0), 0)
+        self.assertEqual(td.get_element_offset(struct_type, 1), 8)
+
+
+class TestTargetMachine(BaseTest):
+
+    def test_add_analysis_passes(self):
+        tm = self.target_machine(jit=False)
+        pm = llvm.create_module_pass_manager()
+        tm.add_analysis_passes(pm)
+
+    def test_target_data_from_tm(self):
+        tm = self.target_machine(jit=False)
+        td = tm.target_data
+        mod = self.module()
+        gv_i32 = mod.get_global_variable("glob")
+        # A global is a pointer, it has the ABI size of a pointer
+        pointer_size = 4 if sys.maxsize < 2 ** 32 else 8
+        self.assertEqual(td.get_abi_size(gv_i32.type), pointer_size)
+
+
+class TestPassManagerBuilder(BaseTest):
+
+    def pmb(self):
+        return llvm.PassManagerBuilder()
+
+    def test_old_api(self):
+        # Test the create_pass_manager_builder() factory function
+        pmb = llvm.create_pass_manager_builder()
+        pmb.inlining_threshold = 2
+        pmb.opt_level = 3
+
+    def test_close(self):
+        pmb = self.pmb()
+        pmb.close()
+        pmb.close()
+
+    def test_opt_level(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.opt_level, int)
+        for i in range(4):
+            pmb.opt_level = i
+            self.assertEqual(pmb.opt_level, i)
+
+    def test_size_level(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.size_level, int)
+        for i in range(4):
+            pmb.size_level = i
+            self.assertEqual(pmb.size_level, i)
+
+    def test_inlining_threshold(self):
+        pmb = self.pmb()
+        with self.assertRaises(NotImplementedError):
+            pmb.inlining_threshold
+        for i in (25, 80, 350):
+            pmb.inlining_threshold = i
+
+    def test_disable_unroll_loops(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.disable_unroll_loops, bool)
+        for b in (True, False):
+            pmb.disable_unroll_loops = b
+            self.assertEqual(pmb.disable_unroll_loops, b)
+
+    def test_loop_vectorize(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.loop_vectorize, bool)
+        for b in (True, False):
+            pmb.loop_vectorize = b
+            self.assertEqual(pmb.loop_vectorize, b)
+
+    def test_slp_vectorize(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.slp_vectorize, bool)
+        for b in (True, False):
+            pmb.slp_vectorize = b
+            self.assertEqual(pmb.slp_vectorize, b)
+
+    def test_populate_module_pass_manager(self):
+        pmb = self.pmb()
+        pm = llvm.create_module_pass_manager()
+        pmb.populate(pm)
+        pmb.close()
+        pm.close()
+
+    def test_populate_function_pass_manager(self):
+        mod = self.module()
+        pmb = self.pmb()
+        pm = llvm.create_function_pass_manager(mod)
+        pmb.populate(pm)
+        pmb.close()
+        pm.close()
+
+
+class PassManagerTestMixin(object):
+
+    def pmb(self):
+        pmb = llvm.create_pass_manager_builder()
+        pmb.opt_level = 2
+        pmb.inlining_threshold = 300
+        return pmb
+
+    def test_close(self):
+        pm = self.pm()
+        pm.close()
+        pm.close()
+
+
+class TestModulePassManager(BaseTest, PassManagerTestMixin):
+
+    def pm(self):
+        return llvm.create_module_pass_manager()
+
+    def test_run(self):
+        pm = self.pm()
+        self.pmb().populate(pm)
+        mod = self.module()
+        orig_asm = str(mod)
+        pm.run(mod)
+        opt_asm = str(mod)
+        # Quick check that optimizations were run, should get:
+        # define i32 @sum(i32 %.1, i32 %.2) local_unnamed_addr #0 {
+        # %.X = add i32 %.2, %.1
+        # ret i32 %.X
+        # }
+        # where X in %.X is 3 or 4
+        opt_asm_split = opt_asm.splitlines()
+        for idx, l in enumerate(opt_asm_split):
+            if l.strip().startswith('ret i32'):
+                toks = {'%.3', '%.4'}
+                for t in toks:
+                    if t in l:
+                        break
+                else:
+                    raise RuntimeError("expected tokens not found")
+                othertoken = (toks ^ {t}).pop()
+
+                self.assertIn("%.3", orig_asm)
+                self.assertNotIn(othertoken, opt_asm)
+                break
+        else:
+            raise RuntimeError("expected IR not found")
+
+    def test_run_with_remarks_successful_inline(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(70)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm2)
+        (status, remarks) = pm.run_with_remarks(mod)
+        self.assertTrue(status)
+        # Inlining has happened?  The remark will tell us.
+        self.assertIn("Passed", remarks)
+        self.assertIn("inlineme", remarks)
+
+    def test_run_with_remarks_failed_inline(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(0)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm3)
+        (status, remarks) = pm.run_with_remarks(mod)
+        self.assertTrue(status)
+
+        # Inlining has not happened?  The remark will tell us.
+        self.assertIn("Missed", remarks)
+        self.assertIn("inlineme", remarks)
+        self.assertIn("noinline function attribute", remarks)
+
+    def test_run_with_remarks_inline_filter_out(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(70)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm2)
+        (status, remarks) = pm.run_with_remarks(mod, remarks_filter="nothing")
+        self.assertTrue(status)
+        self.assertEqual("", remarks)
+
+    def test_run_with_remarks_inline_filter_in(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(70)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm2)
+        (status, remarks) = pm.run_with_remarks(mod, remarks_filter="inlin.*")
+        self.assertTrue(status)
+        self.assertIn("Passed", remarks)
+        self.assertIn("inlineme", remarks)
+
+
+class TestFunctionPassManager(BaseTest, PassManagerTestMixin):
+
+    def pm(self, mod=None):
+        mod = mod or self.module()
+        return llvm.create_function_pass_manager(mod)
+
+    def test_initfini(self):
+        pm = self.pm()
+        pm.initialize()
+        pm.finalize()
+
+    def test_run(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        pm = self.pm(mod)
+        self.pmb().populate(pm)
+        mod.close()
+        orig_asm = str(fn)
+        pm.initialize()
+        pm.run(fn)
+        pm.finalize()
+        opt_asm = str(fn)
+        # Quick check that optimizations were run
+        self.assertIn("%.4", orig_asm)
+        self.assertNotIn("%.4", opt_asm)
+
+    def test_run_with_remarks(self):
+        mod = self.module(licm_asm)
+        fn = mod.get_function("licm")
+        pm = self.pm(mod)
+        pm.add_licm_pass()
+        self.pmb().populate(pm)
+        mod.close()
+
+        pm.initialize()
+        (ok, remarks) = pm.run_with_remarks(fn)
+        pm.finalize()
+        self.assertTrue(ok)
+        self.assertIn("Passed", remarks)
+        self.assertIn("licm", remarks)
+
+    def test_run_with_remarks_filter_out(self):
+        mod = self.module(licm_asm)
+        fn = mod.get_function("licm")
+        pm = self.pm(mod)
+        pm.add_licm_pass()
+        self.pmb().populate(pm)
+        mod.close()
+
+        pm.initialize()
+        (ok, remarks) = pm.run_with_remarks(fn, remarks_filter="nothing")
+        pm.finalize()
+        self.assertTrue(ok)
+        self.assertEqual("", remarks)
+
+    def test_run_with_remarks_filter_in(self):
+        mod = self.module(licm_asm)
+        fn = mod.get_function("licm")
+        pm = self.pm(mod)
+        pm.add_licm_pass()
+        self.pmb().populate(pm)
+        mod.close()
+
+        pm.initialize()
+        (ok, remarks) = pm.run_with_remarks(fn, remarks_filter="licm")
+        pm.finalize()
+        self.assertTrue(ok)
+        self.assertIn("Passed", remarks)
+        self.assertIn("licm", remarks)
+
+
+class TestPasses(BaseTest, PassManagerTestMixin):
+
+    def pm(self):
+        return llvm.create_module_pass_manager()
+
+    def test_populate(self):
+        pm = self.pm()
+        pm.add_target_library_info("") # unspecified target triple
+        pm.add_constant_merge_pass()
+        pm.add_dead_arg_elimination_pass()
+        pm.add_function_attrs_pass()
+        pm.add_function_inlining_pass(225)
+        pm.add_global_dce_pass()
+        pm.add_global_optimizer_pass()
+        pm.add_ipsccp_pass()
+        pm.add_dead_code_elimination_pass()
+        pm.add_cfg_simplification_pass()
+        pm.add_gvn_pass()
+        pm.add_instruction_combining_pass()
+        pm.add_licm_pass()
+        pm.add_sccp_pass()
+        pm.add_sroa_pass()
+        pm.add_type_based_alias_analysis_pass()
+        pm.add_basic_alias_analysis_pass()
+        pm.add_loop_rotate_pass()
+        pm.add_region_info_pass()
+        pm.add_scalar_evolution_aa_pass()
+        pm.add_aggressive_dead_code_elimination_pass()
+        pm.add_aa_eval_pass()
+        pm.add_always_inliner_pass()
+        if llvm_version_major < 15:
+            pm.add_arg_promotion_pass(42)
+        pm.add_break_critical_edges_pass()
+        pm.add_dead_store_elimination_pass()
+        pm.add_reverse_post_order_function_attrs_pass()
+        pm.add_aggressive_instruction_combining_pass()
+        pm.add_internalize_pass()
+        pm.add_jump_threading_pass(7)
+        pm.add_lcssa_pass()
+        pm.add_loop_deletion_pass()
+        pm.add_loop_extractor_pass()
+        pm.add_single_loop_extractor_pass()
+        pm.add_loop_strength_reduce_pass()
+        pm.add_loop_simplification_pass()
+        pm.add_loop_unroll_pass()
+        pm.add_loop_unroll_and_jam_pass()
+        if llvm_version_major < 15:
+            pm.add_loop_unswitch_pass()
+        pm.add_lower_atomic_pass()
+        pm.add_lower_invoke_pass()
+        pm.add_lower_switch_pass()
+        pm.add_memcpy_optimization_pass()
+        pm.add_merge_functions_pass()
+        pm.add_merge_returns_pass()
+        pm.add_partial_inlining_pass()
+        pm.add_prune_exception_handling_pass()
+        pm.add_reassociate_expressions_pass()
+        pm.add_demote_register_to_memory_pass()
+        pm.add_sink_pass()
+        pm.add_strip_symbols_pass()
+        pm.add_strip_dead_debug_info_pass()
+        pm.add_strip_dead_prototypes_pass()
+        pm.add_strip_debug_declare_pass()
+        pm.add_strip_nondebug_symbols_pass()
+        pm.add_tail_call_elimination_pass()
+        pm.add_basic_aa_pass()
+        pm.add_dependence_analysis_pass()
+        pm.add_dot_call_graph_pass()
+        pm.add_dot_cfg_printer_pass()
+        pm.add_dot_dom_printer_pass()
+        pm.add_dot_postdom_printer_pass()
+        pm.add_globals_mod_ref_aa_pass()
+        pm.add_iv_users_pass()
+        pm.add_lazy_value_info_pass()
+        pm.add_lint_pass()
+        pm.add_module_debug_info_pass()
+        pm.add_refprune_pass()
+        pm.add_instruction_namer_pass()
+
+    @unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
+    def test_target_library_info_behavior(self):
+        """Test a specific situation that demonstrate TLI is affecting
+        optimization. See https://github.com/numba/numba/issues/8898.
+        """
+        def run(use_tli):
+            mod = llvm.parse_assembly(asm_tli_exp2)
+            target = llvm.Target.from_triple(mod.triple)
+            tm = target.create_target_machine()
+            pm = llvm.ModulePassManager()
+            tm.add_analysis_passes(pm)
+            if use_tli:
+                pm.add_target_library_info(mod.triple)
+            pm.add_instruction_combining_pass()
+            pm.run(mod)
+            return mod
+
+        # Run with TLI should suppress transformation of exp2 -> ldexpf
+        mod = run(use_tli=True)
+        self.assertIn("call float @llvm.exp2.f32", str(mod))
+
+        # Run without TLI will enable the transformation
+        mod = run(use_tli=False)
+        self.assertNotIn("call float @llvm.exp2.f32", str(mod))
+        self.assertIn("call float @ldexpf", str(mod))
+
+    def test_instruction_namer_pass(self):
+        asm = asm_inlineasm3.format(triple=llvm.get_default_triple())
+        mod = llvm.parse_assembly(asm)
+
+        # Run instnamer pass
+        pm = llvm.ModulePassManager()
+        pm.add_instruction_namer_pass()
+        pm.run(mod)
+
+        # Test that unnamed instructions are now named
+        func = mod.get_function('foo')
+        first_block = next(func.blocks)
+        instructions = list(first_block.instructions)
+        self.assertEqual(instructions[0].name, 'i')
+        self.assertEqual(instructions[1].name, 'i2')
+
+
+class TestDylib(BaseTest):
+
+    def test_bad_library(self):
+        with self.assertRaises(RuntimeError):
+            llvm.load_library_permanently("zzzasdkf;jasd;l")
+
+    @unittest.skipUnless(platform.system() in ["Linux"],
+                         "test only works on Linux")
+    def test_libm(self):
+        libm = find_library("m")
+        llvm.load_library_permanently(libm)
+
+
+class TestAnalysis(BaseTest):
+    def build_ir_module(self):
+        m = ir.Module()
+        ft = ir.FunctionType(ir.IntType(32), [ir.IntType(32), ir.IntType(32)])
+        fn = ir.Function(m, ft, "foo")
+        bd = ir.IRBuilder(fn.append_basic_block())
+        x, y = fn.args
+        z = bd.add(x, y)
+        bd.ret(z)
+        return m
+
+    def test_get_function_cfg_on_ir(self):
+        mod = self.build_ir_module()
+        foo = mod.get_global('foo')
+        dot_showing_inst = llvm.get_function_cfg(foo)
+        dot_without_inst = llvm.get_function_cfg(foo, show_inst=False)
+        inst = "%.5 = add i32 %.1, %.2"
+        self.assertIn(inst, dot_showing_inst)
+        self.assertNotIn(inst, dot_without_inst)
+
+    def test_function_cfg_on_llvm_value(self):
+        defined = self.module().get_function('sum')
+        dot_showing_inst = llvm.get_function_cfg(defined, show_inst=True)
+        dot_without_inst = llvm.get_function_cfg(defined, show_inst=False)
+        # Check "digraph"
+        prefix = 'digraph'
+        self.assertIn(prefix, dot_showing_inst)
+        self.assertIn(prefix, dot_without_inst)
+        # Check function name
+        fname = "CFG for 'sum' function"
+        self.assertIn(fname, dot_showing_inst)
+        self.assertIn(fname, dot_without_inst)
+        # Check instruction
+        inst = "%.3 = add i32 %.1, %.2"
+        self.assertIn(inst, dot_showing_inst)
+        self.assertNotIn(inst, dot_without_inst)
+
+
+class TestTypeParsing(BaseTest):
+    @contextmanager
+    def check_parsing(self):
+        mod = ir.Module()
+        # Yield to caller and provide the module for adding
+        # new GV.
+        yield mod
+        # Caller yield back and continue with testing
+        asm = str(mod)
+        llvm.parse_assembly(asm)
+
+    def test_literal_struct(self):
+        # Natural layout
+        with self.check_parsing() as mod:
+            typ = ir.LiteralStructType([ir.IntType(32)])
+            gv = ir.GlobalVariable(mod, typ, "foo")
+            # Also test constant text repr
+            gv.initializer = ir.Constant(typ, [1])
+
+        # Packed layout
+        with self.check_parsing() as mod:
+            typ = ir.LiteralStructType([ir.IntType(32)],
+                                       packed=True)
+            gv = ir.GlobalVariable(mod, typ, "foo")
+            # Also test constant text repr
+            gv.initializer = ir.Constant(typ, [1])
+
+
+class TestGlobalConstructors(TestMCJit):
+    def test_global_ctors_dtors(self):
+        # test issue #303
+        # (https://github.com/numba/llvmlite/issues/303)
+        mod = self.module(asm_global_ctors)
+        ee = self.jit(mod)
+        ee.finalize_object()
+
+        ee.run_static_constructors()
+
+        # global variable should have been initialized
+        ptr_addr = ee.get_global_value_address("A")
+        ptr_t = ctypes.POINTER(ctypes.c_int32)
+        ptr = ctypes.cast(ptr_addr, ptr_t)
+        self.assertEqual(ptr.contents.value, 10)
+
+        foo_addr = ee.get_function_address("foo")
+        foo = ctypes.CFUNCTYPE(ctypes.c_int32)(foo_addr)
+        self.assertEqual(foo(), 12)
+
+        ee.run_static_destructors()
+
+        # destructor should have run
+        self.assertEqual(ptr.contents.value, 20)
+
+
+class TestGlobalVariables(BaseTest):
+    def check_global_variable_linkage(self, linkage, has_undef=True):
+        # This test default initializer on global variables with different
+        # linkages.  Some linkages requires an initializer be present, while
+        # it is optional for others.  This test uses ``parse_assembly()``
+        # to verify that we are adding an `undef` automatically if user didn't
+        # specific one for certain linkages.  It is a IR syntax error if the
+        # initializer is not present for certain linkages e.g. "external".
+        mod = ir.Module()
+        typ = ir.IntType(32)
+        gv = ir.GlobalVariable(mod, typ, "foo")
+        gv.linkage = linkage
+        asm = str(mod)
+        # check if 'undef' is present
+        if has_undef:
+            self.assertIn('undef', asm)
+        else:
+            self.assertNotIn('undef', asm)
+        # parse assembly to ensure correctness
+        self.module(asm)
+
+    def test_internal_linkage(self):
+        self.check_global_variable_linkage('internal')
+
+    def test_common_linkage(self):
+        self.check_global_variable_linkage('common')
+
+    def test_external_linkage(self):
+        self.check_global_variable_linkage('external', has_undef=False)
+
+    def test_available_externally_linkage(self):
+        self.check_global_variable_linkage('available_externally')
+
+    def test_private_linkage(self):
+        self.check_global_variable_linkage('private')
+
+    def test_linkonce_linkage(self):
+        self.check_global_variable_linkage('linkonce')
+
+    def test_weak_linkage(self):
+        self.check_global_variable_linkage('weak')
+
+    def test_appending_linkage(self):
+        self.check_global_variable_linkage('appending')
+
+    def test_extern_weak_linkage(self):
+        self.check_global_variable_linkage('extern_weak', has_undef=False)
+
+    def test_linkonce_odr_linkage(self):
+        self.check_global_variable_linkage('linkonce_odr')
+
+    def test_weak_odr_linkage(self):
+        self.check_global_variable_linkage('weak_odr')
+
+
+@unittest.skipUnless(platform.machine().startswith('x86'), "only on x86")
+class TestInlineAsm(BaseTest):
+    def test_inlineasm(self):
+        llvm.initialize_native_asmparser()
+        m = self.module(asm=asm_inlineasm)
+        tm = self.target_machine(jit=False)
+        asm = tm.emit_assembly(m)
+        self.assertIn('nop', asm)
+
+
+class TestObjectFile(BaseTest):
+
+    mod_asm = """
+        ;ModuleID = <string>
+        target triple = "{triple}"
+
+        declare i32 @sum(i32 %.1, i32 %.2)
+
+        define i32 @sum_twice(i32 %.1, i32 %.2) {{
+            %.3 = call i32 @sum(i32 %.1, i32 %.2)
+            %.4 = call i32 @sum(i32 %.3, i32 %.3)
+            ret i32 %.4
+        }}
+    """
+
+    def test_object_file(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        obj = llvm.ObjectFileRef.from_data(obj_bin)
+        # Check that we have a text section, and that she has a name and data
+        has_text = False
+        last_address = -1
+        for s in obj.sections():
+            if s.is_text():
+                has_text = True
+                self.assertIsNotNone(s.name())
+                self.assertTrue(s.size() > 0)
+                self.assertTrue(len(s.data()) > 0)
+                self.assertIsNotNone(s.address())
+                self.assertTrue(last_address < s.address())
+                last_address = s.address()
+                break
+        self.assertTrue(has_text)
+
+    def test_add_object_file(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        obj = llvm.ObjectFileRef.from_data(obj_bin)
+
+        jit = llvm.create_mcjit_compiler(self.module(self.mod_asm),
+                                         target_machine)
+
+        jit.add_object_file(obj)
+
+        sum_twice = CFUNCTYPE(c_int, c_int, c_int)(
+            jit.get_function_address("sum_twice"))
+
+        self.assertEqual(sum_twice(2, 3), 10)
+
+    def test_add_object_file_from_filesystem(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        temp_desc, temp_path = mkstemp()
+
+        try:
+            try:
+                f = os.fdopen(temp_desc, "wb")
+                f.write(obj_bin)
+                f.flush()
+            finally:
+                f.close()
+
+            jit = llvm.create_mcjit_compiler(self.module(self.mod_asm),
+                                             target_machine)
+
+            jit.add_object_file(temp_path)
+        finally:
+            os.unlink(temp_path)
+
+        sum_twice = CFUNCTYPE(c_int, c_int, c_int)(
+            jit.get_function_address("sum_twice"))
+
+        self.assertEqual(sum_twice(2, 3), 10)
+
+    def test_get_section_content(self):
+        # See Issue #632 - section contents were getting truncated at null
+        # bytes.
+        elf = bytes.fromhex(issue_632_elf)
+        obj = llvm.ObjectFileRef.from_data(elf)
+        for s in obj.sections():
+            if s.is_text():
+                self.assertEqual(len(s.data()), 31)
+                self.assertEqual(s.data().hex(), issue_632_text)
+
+
+class TestTimePasses(BaseTest):
+    def test_reporting(self):
+        mp = llvm.create_module_pass_manager()
+
+        pmb = llvm.create_pass_manager_builder()
+        pmb.opt_level = 3
+        pmb.populate(mp)
+
+        try:
+            llvm.set_time_passes(True)
+            mp.run(self.module())
+            mp.run(self.module())
+            mp.run(self.module())
+        finally:
+            report = llvm.report_and_reset_timings()
+            llvm.set_time_passes(False)
+
+        self.assertIsInstance(report, str)
+        self.assertEqual(report.count("Pass execution timing report"), 1)
+
+    def test_empty_report(self):
+        # Returns empty str if no data is collected
+        self.assertFalse(llvm.report_and_reset_timings())
+
+
+class TestLLVMLockCallbacks(BaseTest):
+    def test_lock_callbacks(self):
+        events = []
+
+        def acq():
+            events.append('acq')
+
+        def rel():
+            events.append('rel')
+
+        # register callback
+        llvm.ffi.register_lock_callback(acq, rel)
+
+        # Check: events are initially empty
+        self.assertFalse(events)
+        # Call LLVM functions
+        llvm.create_module_pass_manager()
+        # Check: there must be at least one acq and one rel
+        self.assertIn("acq", events)
+        self.assertIn("rel", events)
+
+        # unregister callback
+        llvm.ffi.unregister_lock_callback(acq, rel)
+
+        # Check: removing non-existent callbacks will trigger a ValueError
+        with self.assertRaises(ValueError):
+            llvm.ffi.unregister_lock_callback(acq, rel)
+
+
+if __name__ == "__main__":
+    unittest.main()

vllm/lib/python3.10/site-packages/llvmlite/tests/test_refprune.py

@@ -0,0 +1,557 @@
+import unittest
+from llvmlite import ir
+from llvmlite import binding as llvm
+from llvmlite.tests import TestCase
+
+from . import refprune_proto as proto
+
+
+def _iterate_cases(generate_test):
+    def wrap(fn):
+        def wrapped(self):
+            return generate_test(self, fn)
+        wrapped.__doc__ = f"generated test for {fn.__module__}.{fn.__name__}"
+        return wrapped
+
+    for k, case_fn in proto.__dict__.items():
+        if k.startswith('case'):
+            yield f'test_{k}', wrap(case_fn)
+
+
+class TestRefPrunePrototype(TestCase):
+    """
+    Test that the prototype is working.
+    """
+    def generate_test(self, case_gen):
+        nodes, edges, expected = case_gen()
+        got = proto.FanoutAlgorithm(nodes, edges).run()
+        self.assertEqual(expected, got)
+
+    # Generate tests
+    for name, case in _iterate_cases(generate_test):
+        locals()[name] = case
+
+
+ptr_ty = ir.IntType(8).as_pointer()
+
+
+class TestRefPrunePass(TestCase):
+    """
+    Test that the C++ implementation matches the expected behavior as for
+    the prototype.
+
+    This generates a LLVM module for each test case, runs the pruner and checks
+    that the expected results are achieved.
+    """
+
+    def make_incref(self, m):
+        fnty = ir.FunctionType(ir.VoidType(), [ptr_ty])
+        return ir.Function(m, fnty, name='NRT_incref')
+
+    def make_decref(self, m):
+        fnty = ir.FunctionType(ir.VoidType(), [ptr_ty])
+        return ir.Function(m, fnty, name='NRT_decref')
+
+    def make_switcher(self, m):
+        fnty = ir.FunctionType(ir.IntType(32), ())
+        return ir.Function(m, fnty, name='switcher')
+
+    def make_brancher(self, m):
+        fnty = ir.FunctionType(ir.IntType(1), ())
+        return ir.Function(m, fnty, name='brancher')
+
+    def generate_ir(self, nodes, edges):
+        # Build LLVM module for the CFG
+        m = ir.Module()
+
+        incref_fn = self.make_incref(m)
+        decref_fn = self.make_decref(m)
+        switcher_fn = self.make_switcher(m)
+        brancher_fn = self.make_brancher(m)
+
+        fnty = ir.FunctionType(ir.VoidType(), [ptr_ty])
+        fn = ir.Function(m, fnty, name='main')
+        [ptr] = fn.args
+        ptr.name = 'mem'
+        # populate the BB nodes
+        bbmap = {}
+        for bb in edges:
+            bbmap[bb] = fn.append_basic_block(bb)
+        # populate the BB
+        builder = ir.IRBuilder()
+        for bb, jump_targets in edges.items():
+            builder.position_at_end(bbmap[bb])
+            # Insert increfs and decrefs
+            for action in nodes[bb]:
+                if action == 'incref':
+                    builder.call(incref_fn, [ptr])
+                elif action == 'decref':
+                    builder.call(decref_fn, [ptr])
+                else:
+                    raise AssertionError('unreachable')
+
+            # Insert the terminator.
+            # Switch base on the number of jump targets.
+            n_targets = len(jump_targets)
+            if n_targets == 0:
+                builder.ret_void()
+            elif n_targets == 1:
+                [dst] = jump_targets
+                builder.branch(bbmap[dst])
+            elif n_targets == 2:
+                [left, right] = jump_targets
+                sel = builder.call(brancher_fn, ())
+                builder.cbranch(sel, bbmap[left], bbmap[right])
+            elif n_targets > 2:
+                sel = builder.call(switcher_fn, ())
+                [head, *tail] = jump_targets
+
+                sw = builder.switch(sel, default=bbmap[head])
+                for i, dst in enumerate(tail):
+                    sw.add_case(sel.type(i), bbmap[dst])
+            else:
+                raise AssertionError('unreachable')
+
+        return m
+
+    def apply_refprune(self, irmod):
+        mod = llvm.parse_assembly(str(irmod))
+        pm = llvm.ModulePassManager()
+        pm.add_refprune_pass()
+        pm.run(mod)
+        return mod
+
+    def check(self, mod, expected, nodes):
+        # preprocess incref/decref locations
+        d = {}
+        for k, vs in nodes.items():
+            n_incref = vs.count('incref')
+            n_decref = vs.count('decref')
+            d[k] = {'incref': n_incref, 'decref': n_decref}
+        for k, stats in d.items():
+            if expected.get(k):
+                stats['incref'] -= 1
+                for dec_bb in expected[k]:
+                    d[dec_bb]['decref'] -= 1
+
+        # find the main function
+        for f in mod.functions:
+            if f.name == 'main':
+                break
+        # check each BB
+        for bb in f.blocks:
+            stats = d[bb.name]
+            text = str(bb)
+            n_incref = text.count('NRT_incref')
+            n_decref = text.count('NRT_decref')
+            self.assertEqual(stats['incref'], n_incref, msg=f'BB {bb}')
+            self.assertEqual(stats['decref'], n_decref, msg=f'BB {bb}')
+
+    def generate_test(self, case_gen):
+        nodes, edges, expected = case_gen()
+        irmod = self.generate_ir(nodes, edges)
+        outmod = self.apply_refprune(irmod)
+        self.check(outmod, expected, nodes)
+
+    # Generate tests
+    for name, case in _iterate_cases(generate_test):
+        locals()[name] = case
+
+
+class BaseTestByIR(TestCase):
+    refprune_bitmask = 0
+
+    prologue = r"""
+declare void @NRT_incref(i8* %ptr)
+declare void @NRT_decref(i8* %ptr)
+"""
+
+    def check(self, irmod, subgraph_limit=None):
+        mod = llvm.parse_assembly(f"{self.prologue}\n{irmod}")
+        pm = llvm.ModulePassManager()
+        if subgraph_limit is None:
+            pm.add_refprune_pass(self.refprune_bitmask)
+        else:
+            pm.add_refprune_pass(self.refprune_bitmask,
+                                 subgraph_limit=subgraph_limit)
+        before = llvm.dump_refprune_stats()
+        pm.run(mod)
+        after = llvm.dump_refprune_stats()
+        return mod, after - before
+
+
+class TestPerBB(BaseTestByIR):
+    refprune_bitmask = llvm.RefPruneSubpasses.PER_BB
+
+    per_bb_ir_1 = r"""
+define void @main(i8* %ptr) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_bb_1(self):
+        mod, stats = self.check(self.per_bb_ir_1)
+        self.assertEqual(stats.basicblock, 2)
+
+    per_bb_ir_2 = r"""
+define void @main(i8* %ptr) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_bb_2(self):
+        mod, stats = self.check(self.per_bb_ir_2)
+        self.assertEqual(stats.basicblock, 4)
+        # not pruned
+        self.assertIn("call void @NRT_incref(i8* %ptr)", str(mod))
+
+    per_bb_ir_3 = r"""
+define void @main(i8* %ptr, i8* %other) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %other)
+    ret void
+}
+"""
+
+    def test_per_bb_3(self):
+        mod, stats = self.check(self.per_bb_ir_3)
+        self.assertEqual(stats.basicblock, 2)
+        # not pruned
+        self.assertIn("call void @NRT_decref(i8* %other)", str(mod))
+
+    per_bb_ir_4 = r"""
+; reordered
+define void @main(i8* %ptr, i8* %other) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %other)
+    call void @NRT_incref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_bb_4(self):
+        mod, stats = self.check(self.per_bb_ir_4)
+        self.assertEqual(stats.basicblock, 4)
+        # not pruned
+        self.assertIn("call void @NRT_decref(i8* %other)", str(mod))
+
+
+class TestDiamond(BaseTestByIR):
+    refprune_bitmask = llvm.RefPruneSubpasses.DIAMOND
+
+    per_diamond_1 = r"""
+define void @main(i8* %ptr) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br label %bb_B
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_1(self):
+        mod, stats = self.check(self.per_diamond_1)
+        self.assertEqual(stats.diamond, 2)
+
+    per_diamond_2 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    br label %bb_D
+bb_C:
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_2(self):
+        mod, stats = self.check(self.per_diamond_2)
+        self.assertEqual(stats.diamond, 2)
+
+    per_diamond_3 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    br label %bb_D
+bb_C:
+    call void @NRT_decref(i8* %ptr)  ; reject because of decref in diamond
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_3(self):
+        mod, stats = self.check(self.per_diamond_3)
+        self.assertEqual(stats.diamond, 0)
+
+    per_diamond_4 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_incref(i8* %ptr)     ; extra incref will not affect prune
+    br label %bb_D
+bb_C:
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_4(self):
+        mod, stats = self.check(self.per_diamond_4)
+        self.assertEqual(stats.diamond, 2)
+
+    per_diamond_5 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    br label %bb_D
+bb_C:
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_5(self):
+        mod, stats = self.check(self.per_diamond_5)
+        self.assertEqual(stats.diamond, 4)
+
+
+class TestFanout(BaseTestByIR):
+    """More complex cases are tested in TestRefPrunePass
+    """
+
+    refprune_bitmask = llvm.RefPruneSubpasses.FANOUT
+
+    fanout_1 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+bb_C:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_fanout_1(self):
+        mod, stats = self.check(self.fanout_1)
+        self.assertEqual(stats.fanout, 3)
+
+    fanout_2 = r"""
+define void @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+bb_C:
+    call void @NRT_decref(i8* %ptr)
+    br label %bb_B                      ; illegal jump to other decref
+}
+"""
+
+    def test_fanout_2(self):
+        mod, stats = self.check(self.fanout_2)
+        self.assertEqual(stats.fanout, 0)
+
+    fanout_3 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+bb_C:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_fanout_3(self):
+        mod, stats = self.check(self.fanout_3)
+        self.assertEqual(stats.fanout, 6)
+
+    def test_fanout_3_limited(self):
+        # With subgraph limit at 1, it is essentially turning off the fanout
+        # pruner.
+        mod, stats = self.check(self.fanout_3, subgraph_limit=1)
+        self.assertEqual(stats.fanout, 0)
+
+
+class TestFanoutRaise(BaseTestByIR):
+    refprune_bitmask = llvm.RefPruneSubpasses.FANOUT_RAISE
+
+    fanout_raise_1 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    ret i32 1
+}
+!0 = !{i1 true}
+"""
+
+    def test_fanout_raise_1(self):
+        mod, stats = self.check(self.fanout_raise_1)
+        self.assertEqual(stats.fanout_raise, 2)
+
+    fanout_raise_2 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_typo !0      ; bad metadata
+    ret i32 1
+}
+
+!0 = !{i1 true}
+"""
+
+    def test_fanout_raise_2(self):
+        # This is ensuring that fanout_raise is not pruning when the metadata
+        # is incorrectly named.
+        mod, stats = self.check(self.fanout_raise_2)
+        self.assertEqual(stats.fanout_raise, 0)
+
+    fanout_raise_3 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    ret i32 1
+}
+
+!0 = !{i32 1}       ; ok; use i32
+"""
+
+    def test_fanout_raise_3(self):
+        mod, stats = self.check(self.fanout_raise_3)
+        self.assertEqual(stats.fanout_raise, 2)
+
+    fanout_raise_4 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    ret i32 1    ; BAD; all tails are raising without decref
+bb_C:
+    ret i32 1    ; BAD; all tails are raising without decref
+}
+
+!0 = !{i1 1}
+"""
+
+    def test_fanout_raise_4(self):
+        mod, stats = self.check(self.fanout_raise_4)
+        self.assertEqual(stats.fanout_raise, 0)
+
+    fanout_raise_5 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    br label %common.ret
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    br label %common.ret
+common.ret:
+    %common.ret.op = phi i32 [ 0, %bb_B ], [ 1, %bb_C ]
+    ret i32 %common.ret.op
+}
+!0 = !{i1 1}
+"""
+
+    def test_fanout_raise_5(self):
+        mod, stats = self.check(self.fanout_raise_5)
+        self.assertEqual(stats.fanout_raise, 2)
+
+    # test case 6 is from https://github.com/numba/llvmlite/issues/1023
+    fanout_raise_6 = r"""
+define i32 @main(i8* %ptr, i1 %cond1, i1 %cond2, i1 %cond3, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond1, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    br i1 %cond2, label %bb_D, label %bb_E
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    ret i32 1
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_E:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond3, label %bb_F, label %bb_C
+bb_F:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+}
+!0 = !{i1 1}
+"""
+
+    def test_fanout_raise_6(self):
+        mod, stats = self.check(self.fanout_raise_6)
+        self.assertEqual(stats.fanout_raise, 7)
+
+
+if __name__ == '__main__':
+    unittest.main()

vllm/lib/python3.10/site-packages/mpl_toolkits/axisartist/__init__.py

@@ -0,0 +1,14 @@
+from .axislines import Axes
+from .axislines import (  # noqa: F401
+    AxesZero, AxisArtistHelper, AxisArtistHelperRectlinear,
+    GridHelperBase, GridHelperRectlinear, Subplot, SubplotZero)
+from .axis_artist import AxisArtist, GridlinesCollection  # noqa: F401
+from .grid_helper_curvelinear import GridHelperCurveLinear  # noqa: F401
+from .floating_axes import FloatingAxes, FloatingSubplot  # noqa: F401
+from mpl_toolkits.axes_grid1.parasite_axes import (
+    host_axes_class_factory, parasite_axes_class_factory)
+
+
+ParasiteAxes = parasite_axes_class_factory(Axes)
+HostAxes = host_axes_class_factory(Axes)
+SubplotHost = HostAxes