+ {% endfor %}
+
+
+ """)
+
+
+def reform_code(annotation):
+ """
+ Extract the code from the Numba annotation datastructure.
+
+ Pygments can only highlight full multi-line strings, the Numba
+ annotation is list of single lines, with indentation removed.
+ """
+ ident_dict = annotation['python_indent']
+ s= ''
+ for n,l in annotation['python_lines']:
+ s = s+' '*ident_dict[n]+l+'\n'
+ return s
+
+
+class Annotate:
+ """
+ Construct syntax highlighted annotation for a given jitted function:
+
+ Example:
+
+ >>> import numba
+ >>> from numba.pretty_annotate import Annotate
+ >>> @numba.jit
+ ... def test(q):
+ ... res = 0
+ ... for i in range(q):
+ ... res += i
+ ... return res
+ ...
+ >>> test(10)
+ 45
+ >>> Annotate(test)
+
+ The last line will return an HTML and/or ANSI representation that will be
+ displayed accordingly in Jupyter/IPython.
+
+ Function annotations persist across compilation for newly encountered
+ type signatures and as a result annotations are shown for all signatures
+ by default.
+
+ Annotations for a specific signature can be shown by using the
+ ``signature`` parameter.
+
+ >>> @numba.jit
+ ... def add(x, y):
+ ... return x + y
+ ...
+ >>> add(1, 2)
+ 3
+ >>> add(1.3, 5.7)
+ 7.0
+ >>> add.signatures
+ [(int64, int64), (float64, float64)]
+ >>> Annotate(add, signature=add.signatures[1]) # annotation for (float64, float64)
+ """
+ def __init__(self, function, signature=None, **kwargs):
+
+ style = kwargs.get('style', 'default')
+ if not function.signatures:
+ raise ValueError('function need to be jitted for at least one signature')
+ ann = function.get_annotation_info(signature=signature)
+ self.ann = ann
+
+ for k,v in ann.items():
+ res = hllines(reform_code(v), style)
+ rest = htlines(reform_code(v), style)
+ v['pygments_lines'] = [(a,b,c, d) for (a,b),c, d in zip(v['python_lines'], res, rest)]
+
+ def _repr_html_(self):
+ return get_html_template().render(func_data=self.ann)
+
+ def __repr__(self):
+ return get_ansi_template().render(func_data=self.ann)
diff --git a/venv/lib/python3.10/site-packages/numba/core/annotations/template.html b/venv/lib/python3.10/site-packages/numba/core/annotations/template.html
new file mode 100644
index 0000000000000000000000000000000000000000..73e2f6f855d071bfd54770963dfb741eb700bcd9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/annotations/template.html
@@ -0,0 +1,144 @@
+
+
+
+
+
+
+
+
+
+
+ {% for func_key in func_data.keys() %}
+
+ {% set loop1 = loop %}
+
+
+ Function name: {{func_data[func_key]['funcname']}}
+ in file: {{func_data[func_key]['filename']}}
+ with signature: {{func_key[1]|e}}
+
+
+
+
+
+ {%- for num, line in func_data[func_key]['python_lines'] -%}
+ {%- if func_data[func_key]['ir_lines'][num] %}
+
+
+ {% endfor %}
+
+
+
+
diff --git a/venv/lib/python3.10/site-packages/numba/core/annotations/type_annotations.py b/venv/lib/python3.10/site-packages/numba/core/annotations/type_annotations.py
new file mode 100644
index 0000000000000000000000000000000000000000..47bd0125011fb06550dfd39fc7b56bba9a824cd6
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/annotations/type_annotations.py
@@ -0,0 +1,283 @@
+from collections import defaultdict, OrderedDict
+from collections.abc import Mapping
+from contextlib import closing
+import copy
+import inspect
+import os
+import re
+import sys
+import textwrap
+from io import StringIO
+
+import numba.core.dispatcher
+from numba.core import ir
+
+
+class SourceLines(Mapping):
+ def __init__(self, func):
+
+ try:
+ lines, startno = inspect.getsourcelines(func)
+ except OSError:
+ self.lines = ()
+ self.startno = 0
+ else:
+ self.lines = textwrap.dedent(''.join(lines)).splitlines()
+ self.startno = startno
+
+ def __getitem__(self, lineno):
+ try:
+ return self.lines[lineno - self.startno].rstrip()
+ except IndexError:
+ return ''
+
+ def __iter__(self):
+ return iter((self.startno + i) for i in range(len(self.lines)))
+
+ def __len__(self):
+ return len(self.lines)
+
+ @property
+ def avail(self):
+ return bool(self.lines)
+
+
+class TypeAnnotation(object):
+
+ # func_data dict stores annotation data for all functions that are
+ # compiled. We store the data in the TypeAnnotation class since a new
+ # TypeAnnotation instance is created for each function that is compiled.
+ # For every function that is compiled, we add the type annotation data to
+ # this dict and write the html annotation file to disk (rewrite the html
+ # file for every function since we don't know if this is the last function
+ # to be compiled).
+ func_data = OrderedDict()
+
+ def __init__(self, func_ir, typemap, calltypes, lifted, lifted_from,
+ args, return_type, html_output=None):
+ self.func_id = func_ir.func_id
+ self.blocks = func_ir.blocks
+ self.typemap = typemap
+ self.calltypes = calltypes
+ self.filename = func_ir.loc.filename
+ self.linenum = str(func_ir.loc.line)
+ self.signature = str(args) + ' -> ' + str(return_type)
+
+ # lifted loop information
+ self.lifted = lifted
+ self.num_lifted_loops = len(lifted)
+
+ # If this is a lifted loop function that is being compiled, lifted_from
+ # points to annotation data from function that this loop lifted function
+ # was lifted from. This is used to stick lifted loop annotations back
+ # into original function.
+ self.lifted_from = lifted_from
+
+ def prepare_annotations(self):
+ # Prepare annotations
+ groupedinst = defaultdict(list)
+ found_lifted_loop = False
+ #for blkid, blk in self.blocks.items():
+ for blkid in sorted(self.blocks.keys()):
+ blk = self.blocks[blkid]
+ groupedinst[blk.loc.line].append("label %s" % blkid)
+ for inst in blk.body:
+ lineno = inst.loc.line
+
+ if isinstance(inst, ir.Assign):
+ if found_lifted_loop:
+ atype = 'XXX Lifted Loop XXX'
+ found_lifted_loop = False
+ elif (isinstance(inst.value, ir.Expr) and
+ inst.value.op == 'call'):
+ atype = self.calltypes[inst.value]
+ elif (isinstance(inst.value, ir.Const) and
+ isinstance(inst.value.value, numba.core.dispatcher.LiftedLoop)):
+ atype = 'XXX Lifted Loop XXX'
+ found_lifted_loop = True
+ else:
+ # TODO: fix parfor lowering so that typemap is valid.
+ atype = self.typemap.get(inst.target.name, "")
+
+ aline = "%s = %s :: %s" % (inst.target, inst.value, atype)
+ elif isinstance(inst, ir.SetItem):
+ atype = self.calltypes[inst]
+ aline = "%s :: %s" % (inst, atype)
+ else:
+ aline = "%s" % inst
+ groupedinst[lineno].append(" %s" % aline)
+ return groupedinst
+
+ def annotate(self):
+ source = SourceLines(self.func_id.func)
+ # if not source.avail:
+ # return "Source code unavailable"
+
+ groupedinst = self.prepare_annotations()
+
+ # Format annotations
+ io = StringIO()
+ with closing(io):
+ if source.avail:
+ print("# File: %s" % self.filename, file=io)
+ for num in source:
+ srcline = source[num]
+ ind = _getindent(srcline)
+ print("%s# --- LINE %d --- " % (ind, num), file=io)
+ for inst in groupedinst[num]:
+ print('%s# %s' % (ind, inst), file=io)
+ print(file=io)
+ print(srcline, file=io)
+ print(file=io)
+ if self.lifted:
+ print("# The function contains lifted loops", file=io)
+ for loop in self.lifted:
+ print("# Loop at line %d" % loop.get_source_location(),
+ file=io)
+ print("# Has %d overloads" % len(loop.overloads),
+ file=io)
+ for cres in loop.overloads.values():
+ print(cres.type_annotation, file=io)
+ else:
+ print("# Source code unavailable", file=io)
+ for num in groupedinst:
+ for inst in groupedinst[num]:
+ print('%s' % (inst,), file=io)
+ print(file=io)
+
+ return io.getvalue()
+
+ def html_annotate(self, outfile):
+ # ensure that annotation information is assembled
+ self.annotate_raw()
+ # make a deep copy ahead of the pending mutations
+ func_data = copy.deepcopy(self.func_data)
+
+ key = 'python_indent'
+ for this_func in func_data.values():
+ if key in this_func:
+ idents = {}
+ for line, amount in this_func[key].items():
+ idents[line] = ' ' * amount
+ this_func[key] = idents
+
+ key = 'ir_indent'
+ for this_func in func_data.values():
+ if key in this_func:
+ idents = {}
+ for line, ir_id in this_func[key].items():
+ idents[line] = [' ' * amount for amount in ir_id]
+ this_func[key] = idents
+
+
+
+ try:
+ from jinja2 import Template
+ except ImportError:
+ raise ImportError("please install the 'jinja2' package")
+
+ root = os.path.join(os.path.dirname(__file__))
+ template_filename = os.path.join(root, 'template.html')
+ with open(template_filename, 'r') as template:
+ html = template.read()
+
+ template = Template(html)
+ rendered = template.render(func_data=func_data)
+ outfile.write(rendered)
+
+ def annotate_raw(self):
+ """
+ This returns "raw" annotation information i.e. it has no output format
+ specific markup included.
+ """
+ python_source = SourceLines(self.func_id.func)
+ ir_lines = self.prepare_annotations()
+ line_nums = [num for num in python_source]
+ lifted_lines = [l.get_source_location() for l in self.lifted]
+
+ def add_ir_line(func_data, line):
+ line_str = line.strip()
+ line_type = ''
+ if line_str.endswith('pyobject'):
+ line_str = line_str.replace('pyobject', '')
+ line_type = 'pyobject'
+ func_data['ir_lines'][num].append((line_str, line_type))
+ indent_len = len(_getindent(line))
+ func_data['ir_indent'][num].append(indent_len)
+
+ func_key = (self.func_id.filename + ':' + str(self.func_id.firstlineno + 1),
+ self.signature)
+ if self.lifted_from is not None and self.lifted_from[1]['num_lifted_loops'] > 0:
+ # This is a lifted loop function that is being compiled. Get the
+ # numba ir for lines in loop function to use for annotating
+ # original python function that the loop was lifted from.
+ func_data = self.lifted_from[1]
+ for num in line_nums:
+ if num not in ir_lines.keys():
+ continue
+ func_data['ir_lines'][num] = []
+ func_data['ir_indent'][num] = []
+ for line in ir_lines[num]:
+ add_ir_line(func_data, line)
+ if line.strip().endswith('pyobject'):
+ func_data['python_tags'][num] = 'object_tag'
+ # If any pyobject line is found, make sure original python
+ # line that was marked as a lifted loop start line is tagged
+ # as an object line instead. Lifted loop start lines should
+ # only be marked as lifted loop lines if the lifted loop
+ # was successfully compiled in nopython mode.
+ func_data['python_tags'][self.lifted_from[0]] = 'object_tag'
+
+ # We're done with this lifted loop, so decrement lifted loop counter.
+ # When lifted loop counter hits zero, that means we're ready to write
+ # out annotations to html file.
+ self.lifted_from[1]['num_lifted_loops'] -= 1
+
+ elif func_key not in TypeAnnotation.func_data.keys():
+ TypeAnnotation.func_data[func_key] = {}
+ func_data = TypeAnnotation.func_data[func_key]
+
+ for i, loop in enumerate(self.lifted):
+ # Make sure that when we process each lifted loop function later,
+ # we'll know where it originally came from.
+ loop.lifted_from = (lifted_lines[i], func_data)
+ func_data['num_lifted_loops'] = self.num_lifted_loops
+
+ func_data['filename'] = self.filename
+ func_data['funcname'] = self.func_id.func_name
+ func_data['python_lines'] = []
+ func_data['python_indent'] = {}
+ func_data['python_tags'] = {}
+ func_data['ir_lines'] = {}
+ func_data['ir_indent'] = {}
+
+ for num in line_nums:
+ func_data['python_lines'].append((num, python_source[num].strip()))
+ indent_len = len(_getindent(python_source[num]))
+ func_data['python_indent'][num] = indent_len
+ func_data['python_tags'][num] = ''
+ func_data['ir_lines'][num] = []
+ func_data['ir_indent'][num] = []
+
+ for line in ir_lines[num]:
+ add_ir_line(func_data, line)
+ if num in lifted_lines:
+ func_data['python_tags'][num] = 'lifted_tag'
+ elif line.strip().endswith('pyobject'):
+ func_data['python_tags'][num] = 'object_tag'
+ return self.func_data
+
+
+ def __str__(self):
+ return self.annotate()
+
+
+re_longest_white_prefix = re.compile(r'^\s*')
+
+
+def _getindent(text):
+ m = re_longest_white_prefix.match(text)
+ if not m:
+ return ''
+ else:
+ return ' ' * len(m.group(0))
diff --git a/venv/lib/python3.10/site-packages/numba/core/base.py b/venv/lib/python3.10/site-packages/numba/core/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..355235b2349ebf06c302ee36beddf4dbb9c5189e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/base.py
@@ -0,0 +1,1255 @@
+from collections import defaultdict
+import copy
+import sys
+from itertools import permutations, takewhile
+from contextlib import contextmanager
+from functools import cached_property
+
+from llvmlite import ir as llvmir
+from llvmlite.ir import Constant
+import llvmlite.binding as ll
+
+from numba.core import types, utils, datamodel, debuginfo, funcdesc, config, cgutils, imputils
+from numba.core import event, errors, targetconfig
+from numba import _dynfunc, _helperlib
+from numba.core.compiler_lock import global_compiler_lock
+from numba.core.pythonapi import PythonAPI
+from numba.core.imputils import (user_function, user_generator,
+ builtin_registry, impl_ret_borrowed,
+ RegistryLoader)
+from numba.cpython import builtins
+
+GENERIC_POINTER = llvmir.PointerType(llvmir.IntType(8))
+PYOBJECT = GENERIC_POINTER
+void_ptr = GENERIC_POINTER
+
+
+class OverloadSelector(object):
+ """
+ An object matching an actual signature against a registry of formal
+ signatures and choosing the best candidate, if any.
+
+ In the current implementation:
+ - a "signature" is a tuple of type classes or type instances
+ - the "best candidate" is the most specific match
+ """
+
+ def __init__(self):
+ # A list of (formal args tuple, value)
+ self.versions = []
+ self._cache = {}
+
+ def find(self, sig):
+ out = self._cache.get(sig)
+ if out is None:
+ out = self._find(sig)
+ self._cache[sig] = out
+ return out
+
+ def _find(self, sig):
+ candidates = self._select_compatible(sig)
+ if candidates:
+ return candidates[self._best_signature(candidates)]
+ else:
+ raise errors.NumbaNotImplementedError(f'{self}, {sig}')
+
+ def _select_compatible(self, sig):
+ """
+ Select all compatible signatures and their implementation.
+ """
+ out = {}
+ for ver_sig, impl in self.versions:
+ if self._match_arglist(ver_sig, sig):
+ out[ver_sig] = impl
+ return out
+
+ def _best_signature(self, candidates):
+ """
+ Returns the best signature out of the candidates
+ """
+ ordered, genericity = self._sort_signatures(candidates)
+ # check for ambiguous signatures
+ if len(ordered) > 1:
+ firstscore = genericity[ordered[0]]
+ same = list(takewhile(lambda x: genericity[x] == firstscore,
+ ordered))
+ if len(same) > 1:
+ msg = ["{n} ambiguous signatures".format(n=len(same))]
+ for sig in same:
+ msg += ["{0} => {1}".format(sig, candidates[sig])]
+ raise errors.NumbaTypeError('\n'.join(msg))
+ return ordered[0]
+
+ def _sort_signatures(self, candidates):
+ """
+ Sort signatures in ascending level of genericity.
+
+ Returns a 2-tuple:
+
+ * ordered list of signatures
+ * dictionary containing genericity scores
+ """
+ # score by genericity
+ genericity = defaultdict(int)
+ for this, other in permutations(candidates.keys(), r=2):
+ matched = self._match_arglist(formal_args=this, actual_args=other)
+ if matched:
+ # genericity score +1 for every another compatible signature
+ genericity[this] += 1
+ # order candidates in ascending level of genericity
+ ordered = sorted(candidates.keys(), key=lambda x: genericity[x])
+ return ordered, genericity
+
+ def _match_arglist(self, formal_args, actual_args):
+ """
+ Returns True if the signature is "matching".
+ A formal signature is "matching" if the actual signature matches exactly
+ or if the formal signature is a compatible generic signature.
+ """
+ # normalize VarArg
+ if formal_args and isinstance(formal_args[-1], types.VarArg):
+ ndiff = len(actual_args) - len(formal_args) + 1
+ formal_args = formal_args[:-1] + (formal_args[-1].dtype,) * ndiff
+
+ if len(formal_args) != len(actual_args):
+ return False
+
+ for formal, actual in zip(formal_args, actual_args):
+ if not self._match(formal, actual):
+ return False
+
+ return True
+
+ def _match(self, formal, actual):
+ if formal == actual:
+ # formal argument matches actual arguments
+ return True
+ elif types.Any == formal:
+ # formal argument is any
+ return True
+ elif isinstance(formal, type) and issubclass(formal, types.Type):
+ if isinstance(actual, type) and issubclass(actual, formal):
+ # formal arg is a type class and actual arg is a subclass
+ return True
+ elif isinstance(actual, formal):
+ # formal arg is a type class of which actual arg is an instance
+ return True
+
+ def append(self, value, sig):
+ """
+ Add a formal signature and its associated value.
+ """
+ assert isinstance(sig, tuple), (value, sig)
+ self.versions.append((sig, value))
+ self._cache.clear()
+
+
+@utils.runonce
+def _load_global_helpers():
+ """
+ Execute once to install special symbols into the LLVM symbol table.
+ """
+ # This is Py_None's real C name
+ ll.add_symbol("_Py_NoneStruct", id(None))
+
+ # Add Numba C helper functions
+ for c_helpers in (_helperlib.c_helpers, _dynfunc.c_helpers):
+ for py_name, c_address in c_helpers.items():
+ c_name = "numba_" + py_name
+ ll.add_symbol(c_name, c_address)
+
+ # Add all built-in exception classes
+ for obj in utils.builtins.__dict__.values():
+ if isinstance(obj, type) and issubclass(obj, BaseException):
+ ll.add_symbol("PyExc_%s" % (obj.__name__), id(obj))
+
+
+class BaseContext(object):
+ """
+
+ Notes on Structure
+ ------------------
+
+ Most objects are lowered as plain-old-data structure in the generated
+ llvm. They are passed around by reference (a pointer to the structure).
+ Only POD structure can live across function boundaries by copying the
+ data.
+ """
+ # True if the target requires strict alignment
+ # Causes exception to be raised if the record members are not aligned.
+ strict_alignment = False
+
+ # Force powi implementation as math.pow call
+ implement_powi_as_math_call = False
+ implement_pow_as_math_call = False
+
+ # Emit Debug info
+ enable_debuginfo = False
+ DIBuilder = debuginfo.DIBuilder
+
+ # Bound checking
+ @property
+ def enable_boundscheck(self):
+ if config.BOUNDSCHECK is not None:
+ return config.BOUNDSCHECK
+ return self._boundscheck
+
+ @enable_boundscheck.setter
+ def enable_boundscheck(self, value):
+ self._boundscheck = value
+
+ # NRT
+ enable_nrt = False
+
+ # Auto parallelization
+ auto_parallel = False
+
+ # PYCC
+ aot_mode = False
+
+ # Error model for various operations (only FP exceptions currently)
+ error_model = None
+
+ # Whether dynamic globals (CPU runtime addresses) is allowed
+ allow_dynamic_globals = False
+
+ # Fast math flags
+ fastmath = False
+
+ # python execution environment
+ environment = None
+
+ # the function descriptor
+ fndesc = None
+
+ def __init__(self, typing_context, target):
+ _load_global_helpers()
+
+ self.address_size = utils.MACHINE_BITS
+ self.typing_context = typing_context
+ from numba.core.target_extension import target_registry
+ self.target_name = target
+ self.target = target_registry[target]
+
+ # A mapping of installed registries to their loaders
+ self._registries = {}
+ # Declarations loaded from registries and other sources
+ self._defns = defaultdict(OverloadSelector)
+ self._getattrs = defaultdict(OverloadSelector)
+ self._setattrs = defaultdict(OverloadSelector)
+ self._casts = OverloadSelector()
+ self._get_constants = OverloadSelector()
+ # Other declarations
+ self._generators = {}
+ self.special_ops = {}
+ self.cached_internal_func = {}
+ self._pid = None
+ self._codelib_stack = []
+
+ self._boundscheck = False
+
+ self.data_model_manager = datamodel.default_manager
+
+ # Initialize
+ self.init()
+
+ def init(self):
+ """
+ For subclasses to add initializer
+ """
+
+ def refresh(self):
+ """
+ Refresh context with new declarations from known registries.
+ Useful for third-party extensions.
+ """
+ # load target specific registries
+ self.load_additional_registries()
+
+ # Populate the builtin registry, this has to happen after loading
+ # additional registries as some of the "additional" registries write
+ # their implementations into the builtin_registry and would be missed if
+ # this ran first.
+ self.install_registry(builtin_registry)
+
+ # Also refresh typing context, since @overload declarations can
+ # affect it.
+ self.typing_context.refresh()
+
+ def load_additional_registries(self):
+ """
+ Load target-specific registries. Can be overridden by subclasses.
+ """
+
+ def mangler(self, name, types, *, abi_tags=(), uid=None):
+ """
+ Perform name mangling.
+ """
+ return funcdesc.default_mangler(name, types, abi_tags=abi_tags, uid=uid)
+
+ def get_env_name(self, fndesc):
+ """Get the environment name given a FunctionDescriptor.
+
+ Use this instead of the ``fndesc.env_name`` so that the target-context
+ can provide necessary mangling of the symbol to meet ABI requirements.
+ """
+ return fndesc.env_name
+
+ def declare_env_global(self, module, envname):
+ """Declare the Environment pointer as a global of the module.
+
+ The pointer is initialized to NULL. It must be filled by the runtime
+ with the actual address of the Env before the associated function
+ can be executed.
+
+ Parameters
+ ----------
+ module :
+ The LLVM Module
+ envname : str
+ The name of the global variable.
+ """
+ if envname not in module.globals:
+ gv = llvmir.GlobalVariable(module, cgutils.voidptr_t, name=envname)
+ gv.linkage = 'common'
+ gv.initializer = cgutils.get_null_value(gv.type.pointee)
+
+ return module.globals[envname]
+
+ def get_arg_packer(self, fe_args):
+ return datamodel.ArgPacker(self.data_model_manager, fe_args)
+
+ def get_data_packer(self, fe_types):
+ return datamodel.DataPacker(self.data_model_manager, fe_types)
+
+ @property
+ def target_data(self):
+ raise NotImplementedError
+
+ @cached_property
+ def nonconst_module_attrs(self):
+ """
+ All module attrs are constant for targets using BaseContext.
+ """
+ return tuple()
+
+ @cached_property
+ def nrt(self):
+ from numba.core.runtime.context import NRTContext
+ return NRTContext(self, self.enable_nrt)
+
+ def subtarget(self, **kws):
+ obj = copy.copy(self) # shallow copy
+ for k, v in kws.items():
+ if not hasattr(obj, k):
+ raise NameError("unknown option {0!r}".format(k))
+ setattr(obj, k, v)
+ if obj.codegen() is not self.codegen():
+ # We can't share functions across different codegens
+ obj.cached_internal_func = {}
+ return obj
+
+ def install_registry(self, registry):
+ """
+ Install a *registry* (a imputils.Registry instance) of function
+ and attribute implementations.
+ """
+ try:
+ loader = self._registries[registry]
+ except KeyError:
+ loader = RegistryLoader(registry)
+ self._registries[registry] = loader
+ self.insert_func_defn(loader.new_registrations('functions'))
+ self._insert_getattr_defn(loader.new_registrations('getattrs'))
+ self._insert_setattr_defn(loader.new_registrations('setattrs'))
+ self._insert_cast_defn(loader.new_registrations('casts'))
+ self._insert_get_constant_defn(loader.new_registrations('constants'))
+
+ def insert_func_defn(self, defns):
+ for impl, func, sig in defns:
+ self._defns[func].append(impl, sig)
+
+ def _insert_getattr_defn(self, defns):
+ for impl, attr, sig in defns:
+ self._getattrs[attr].append(impl, sig)
+
+ def _insert_setattr_defn(self, defns):
+ for impl, attr, sig in defns:
+ self._setattrs[attr].append(impl, sig)
+
+ def _insert_cast_defn(self, defns):
+ for impl, sig in defns:
+ self._casts.append(impl, sig)
+
+ def _insert_get_constant_defn(self, defns):
+ for impl, sig in defns:
+ self._get_constants.append(impl, sig)
+
+ def insert_user_function(self, func, fndesc, libs=()):
+ impl = user_function(fndesc, libs)
+ self._defns[func].append(impl, impl.signature)
+
+ def insert_generator(self, genty, gendesc, libs=()):
+ assert isinstance(genty, types.Generator)
+ impl = user_generator(gendesc, libs)
+ self._generators[genty] = gendesc, impl
+
+ def remove_user_function(self, func):
+ """
+ Remove user function *func*.
+ KeyError is raised if the function isn't known to us.
+ """
+ del self._defns[func]
+
+ def get_external_function_type(self, fndesc):
+ argtypes = [self.get_argument_type(aty)
+ for aty in fndesc.argtypes]
+ # don't wrap in pointer
+ restype = self.get_argument_type(fndesc.restype)
+ fnty = llvmir.FunctionType(restype, argtypes)
+ return fnty
+
+ def declare_function(self, module, fndesc):
+ fnty = self.call_conv.get_function_type(fndesc.restype, fndesc.argtypes)
+ fn = cgutils.get_or_insert_function(module, fnty, fndesc.mangled_name)
+ self.call_conv.decorate_function(fn, fndesc.args, fndesc.argtypes, noalias=fndesc.noalias)
+ if fndesc.inline:
+ fn.attributes.add('alwaysinline')
+ # alwaysinline overrides optnone
+ fn.attributes.discard('noinline')
+ fn.attributes.discard('optnone')
+ return fn
+
+ def declare_external_function(self, module, fndesc):
+ fnty = self.get_external_function_type(fndesc)
+ fn = cgutils.get_or_insert_function(module, fnty, fndesc.mangled_name)
+ assert fn.is_declaration
+ for ak, av in zip(fndesc.args, fn.args):
+ av.name = "arg.%s" % ak
+ return fn
+
+ def insert_const_string(self, mod, string):
+ """
+ Insert constant *string* (a str object) into module *mod*.
+ """
+ stringtype = GENERIC_POINTER
+ name = ".const.%s" % string
+ text = cgutils.make_bytearray(string.encode("utf-8") + b"\x00")
+ gv = self.insert_unique_const(mod, name, text)
+ return Constant.bitcast(gv, stringtype)
+
+ def insert_const_bytes(self, mod, bytes, name=None):
+ """
+ Insert constant *byte* (a `bytes` object) into module *mod*.
+ """
+ stringtype = GENERIC_POINTER
+ name = ".bytes.%s" % (name or hash(bytes))
+ text = cgutils.make_bytearray(bytes)
+ gv = self.insert_unique_const(mod, name, text)
+ return Constant.bitcast(gv, stringtype)
+
+ def insert_unique_const(self, mod, name, val):
+ """
+ Insert a unique internal constant named *name*, with LLVM value
+ *val*, into module *mod*.
+ """
+ try:
+ gv = mod.get_global(name)
+ except KeyError:
+ return cgutils.global_constant(mod, name, val)
+ else:
+ return gv
+
+ def get_argument_type(self, ty):
+ return self.data_model_manager[ty].get_argument_type()
+
+ def get_return_type(self, ty):
+ return self.data_model_manager[ty].get_return_type()
+
+ def get_data_type(self, ty):
+ """
+ Get a LLVM data representation of the Numba type *ty* that is safe
+ for storage. Record data are stored as byte array.
+
+ The return value is a llvmlite.ir.Type object, or None if the type
+ is an opaque pointer (???).
+ """
+ return self.data_model_manager[ty].get_data_type()
+
+ def get_value_type(self, ty):
+ return self.data_model_manager[ty].get_value_type()
+
+ def pack_value(self, builder, ty, value, ptr, align=None):
+ """
+ Pack value into the array storage at *ptr*.
+ If *align* is given, it is the guaranteed alignment for *ptr*
+ (by default, the standard ABI alignment).
+ """
+ dataval = self.data_model_manager[ty].as_data(builder, value)
+ builder.store(dataval, ptr, align=align)
+
+ def unpack_value(self, builder, ty, ptr, align=None):
+ """
+ Unpack value from the array storage at *ptr*.
+ If *align* is given, it is the guaranteed alignment for *ptr*
+ (by default, the standard ABI alignment).
+ """
+ dm = self.data_model_manager[ty]
+ return dm.load_from_data_pointer(builder, ptr, align)
+
+ def get_constant_generic(self, builder, ty, val):
+ """
+ Return a LLVM constant representing value *val* of Numba type *ty*.
+ """
+ try:
+ impl = self._get_constants.find((ty,))
+ return impl(self, builder, ty, val)
+ except NotImplementedError:
+ raise NotImplementedError("Cannot lower constant of type '%s'" % (ty,))
+
+ def get_constant(self, ty, val):
+ """
+ Same as get_constant_generic(), but without specifying *builder*.
+ Works only for simple types.
+ """
+ # HACK: pass builder=None to preserve get_constant() API
+ return self.get_constant_generic(None, ty, val)
+
+ def get_constant_undef(self, ty):
+ lty = self.get_value_type(ty)
+ return Constant(lty, llvmir.Undefined)
+
+ def get_constant_null(self, ty):
+ lty = self.get_value_type(ty)
+ return Constant(lty, None)
+
+ def get_function(self, fn, sig, _firstcall=True):
+ """
+ Return the implementation of function *fn* for signature *sig*.
+ The return value is a callable with the signature (builder, args).
+ """
+ assert sig is not None
+ sig = sig.as_function()
+ if isinstance(fn, types.Callable):
+ key = fn.get_impl_key(sig)
+ overloads = self._defns[key]
+ else:
+ key = fn
+ overloads = self._defns[key]
+
+ try:
+ return _wrap_impl(overloads.find(sig.args), self, sig)
+ except errors.NumbaNotImplementedError:
+ pass
+ if isinstance(fn, types.Type):
+ # It's a type instance => try to find a definition for the type class
+ try:
+ return self.get_function(type(fn), sig)
+ except NotImplementedError:
+ # Raise exception for the type instance, for a better error message
+ pass
+
+ # Automatically refresh the context to load new registries if we are
+ # calling the first time.
+ if _firstcall:
+ self.refresh()
+ return self.get_function(fn, sig, _firstcall=False)
+
+ raise NotImplementedError("No definition for lowering %s%s" % (key, sig))
+
+ def get_generator_desc(self, genty):
+ """
+ """
+ return self._generators[genty][0]
+
+ def get_generator_impl(self, genty):
+ """
+ """
+ res = self._generators[genty][1]
+ self.add_linking_libs(getattr(res, 'libs', ()))
+ return res
+
+ def get_bound_function(self, builder, obj, ty):
+ assert self.get_value_type(ty) == obj.type
+ return obj
+
+ def get_getattr(self, typ, attr):
+ """
+ Get the getattr() implementation for the given type and attribute name.
+ The return value is a callable with the signature
+ (context, builder, typ, val, attr).
+ """
+ const_attr = (typ, attr) not in self.nonconst_module_attrs
+ is_module = isinstance(typ, types.Module)
+ if is_module and const_attr:
+ # Implement getattr for module-level globals that we treat as
+ # constants.
+ # XXX We shouldn't have to retype this
+ attrty = self.typing_context.resolve_module_constants(typ, attr)
+ if attrty is None or isinstance(attrty, types.Dummy):
+ # No implementation required for dummies (functions, modules...),
+ # which are dealt with later
+ return None
+ else:
+ pyval = getattr(typ.pymod, attr)
+ def imp(context, builder, typ, val, attr):
+ llval = self.get_constant_generic(builder, attrty, pyval)
+ return impl_ret_borrowed(context, builder, attrty, llval)
+ return imp
+
+ # Lookup specific getattr implementation for this type and attribute
+ overloads = self._getattrs[attr]
+ try:
+ return overloads.find((typ,))
+ except errors.NumbaNotImplementedError:
+ pass
+ # Lookup generic getattr implementation for this type
+ overloads = self._getattrs[None]
+ try:
+ return overloads.find((typ,))
+ except errors.NumbaNotImplementedError:
+ pass
+
+ raise NotImplementedError("No definition for lowering %s.%s" % (typ, attr))
+
+ def get_setattr(self, attr, sig):
+ """
+ Get the setattr() implementation for the given attribute name
+ and signature.
+ The return value is a callable with the signature (builder, args).
+ """
+ assert len(sig.args) == 2
+ typ = sig.args[0]
+ valty = sig.args[1]
+
+ def wrap_setattr(impl):
+ def wrapped(builder, args):
+ return impl(self, builder, sig, args, attr)
+ return wrapped
+
+ # Lookup specific setattr implementation for this type and attribute
+ overloads = self._setattrs[attr]
+ try:
+ return wrap_setattr(overloads.find((typ, valty)))
+ except errors.NumbaNotImplementedError:
+ pass
+ # Lookup generic setattr implementation for this type
+ overloads = self._setattrs[None]
+ try:
+ return wrap_setattr(overloads.find((typ, valty)))
+ except errors.NumbaNotImplementedError:
+ pass
+
+ raise NotImplementedError("No definition for lowering %s.%s = %s"
+ % (typ, attr, valty))
+
+ def get_argument_value(self, builder, ty, val):
+ """
+ Argument representation to local value representation
+ """
+ return self.data_model_manager[ty].from_argument(builder, val)
+
+ def get_returned_value(self, builder, ty, val):
+ """
+ Return value representation to local value representation
+ """
+ return self.data_model_manager[ty].from_return(builder, val)
+
+ def get_return_value(self, builder, ty, val):
+ """
+ Local value representation to return type representation
+ """
+ return self.data_model_manager[ty].as_return(builder, val)
+
+ def get_value_as_argument(self, builder, ty, val):
+ """Prepare local value representation as argument type representation
+ """
+ return self.data_model_manager[ty].as_argument(builder, val)
+
+ def get_value_as_data(self, builder, ty, val):
+ return self.data_model_manager[ty].as_data(builder, val)
+
+ def get_data_as_value(self, builder, ty, val):
+ return self.data_model_manager[ty].from_data(builder, val)
+
+ def pair_first(self, builder, val, ty):
+ """
+ Extract the first element of a heterogeneous pair.
+ """
+ pair = self.make_helper(builder, ty, val)
+ return pair.first
+
+ def pair_second(self, builder, val, ty):
+ """
+ Extract the second element of a heterogeneous pair.
+ """
+ pair = self.make_helper(builder, ty, val)
+ return pair.second
+
+ def cast(self, builder, val, fromty, toty):
+ """
+ Cast a value of type *fromty* to type *toty*.
+ This implements implicit conversions as can happen due to the
+ granularity of the Numba type system, or lax Python semantics.
+ """
+ if fromty is types._undef_var:
+ # Special case for undefined variable
+ return self.get_constant_null(toty)
+ elif fromty == toty or toty == types.Any:
+ return val
+ try:
+ impl = self._casts.find((fromty, toty))
+ return impl(self, builder, fromty, toty, val)
+ except errors.NumbaNotImplementedError:
+ raise errors.NumbaNotImplementedError(
+ "Cannot cast %s to %s: %s" % (fromty, toty, val))
+
+ def generic_compare(self, builder, key, argtypes, args):
+ """
+ Compare the given LLVM values of the given Numba types using
+ the comparison *key* (e.g. '=='). The values are first cast to
+ a common safe conversion type.
+ """
+ at, bt = argtypes
+ av, bv = args
+ ty = self.typing_context.unify_types(at, bt)
+ assert ty is not None
+ cav = self.cast(builder, av, at, ty)
+ cbv = self.cast(builder, bv, bt, ty)
+ fnty = self.typing_context.resolve_value_type(key)
+ # the sig is homogeneous in the unified casted type
+ cmpsig = fnty.get_call_type(self.typing_context, (ty, ty), {})
+ cmpfunc = self.get_function(fnty, cmpsig)
+ self.add_linking_libs(getattr(cmpfunc, 'libs', ()))
+ return cmpfunc(builder, (cav, cbv))
+
+ def make_optional_none(self, builder, valtype):
+ optval = self.make_helper(builder, types.Optional(valtype))
+ optval.valid = cgutils.false_bit
+ return optval._getvalue()
+
+ def make_optional_value(self, builder, valtype, value):
+ optval = self.make_helper(builder, types.Optional(valtype))
+ optval.valid = cgutils.true_bit
+ optval.data = value
+ return optval._getvalue()
+
+ def is_true(self, builder, typ, val):
+ """
+ Return the truth value of a value of the given Numba type.
+ """
+ fnty = self.typing_context.resolve_value_type(bool)
+ sig = fnty.get_call_type(self.typing_context, (typ,), {})
+ impl = self.get_function(fnty, sig)
+ return impl(builder, (val,))
+
+ def get_c_value(self, builder, typ, name, dllimport=False):
+ """
+ Get a global value through its C-accessible *name*, with the given
+ LLVM type.
+ If *dllimport* is true, the symbol will be marked as imported
+ from a DLL (necessary for AOT compilation under Windows).
+ """
+ module = builder.function.module
+ try:
+ gv = module.globals[name]
+ except KeyError:
+ gv = cgutils.add_global_variable(module, typ, name)
+ if dllimport and self.aot_mode and sys.platform == 'win32':
+ gv.storage_class = "dllimport"
+ return gv
+
+ def call_external_function(self, builder, callee, argtys, args):
+ args = [self.get_value_as_argument(builder, ty, arg)
+ for ty, arg in zip(argtys, args)]
+ retval = builder.call(callee, args)
+ return retval
+
+ def get_function_pointer_type(self, typ):
+ return self.data_model_manager[typ].get_data_type()
+
+ def call_function_pointer(self, builder, funcptr, args, cconv=None):
+ return builder.call(funcptr, args, cconv=cconv)
+
+ def print_string(self, builder, text):
+ mod = builder.module
+ cstring = GENERIC_POINTER
+ fnty = llvmir.FunctionType(llvmir.IntType(32), [cstring])
+ puts = cgutils.get_or_insert_function(mod, fnty, "puts")
+ return builder.call(puts, [text])
+
+ def debug_print(self, builder, text):
+ mod = builder.module
+ cstr = self.insert_const_string(mod, str(text))
+ self.print_string(builder, cstr)
+
+ def printf(self, builder, format_string, *args):
+ mod = builder.module
+ if isinstance(format_string, str):
+ cstr = self.insert_const_string(mod, format_string)
+ else:
+ cstr = format_string
+ fnty = llvmir.FunctionType(llvmir.IntType(32), (GENERIC_POINTER,), var_arg=True)
+ fn = cgutils.get_or_insert_function(mod, fnty, "printf")
+ return builder.call(fn, (cstr,) + tuple(args))
+
+ def get_struct_type(self, struct):
+ """
+ Get the LLVM struct type for the given Structure class *struct*.
+ """
+ fields = [self.get_value_type(v) for _, v in struct._fields]
+ return llvmir.LiteralStructType(fields)
+
+ def get_dummy_value(self):
+ return Constant(self.get_dummy_type(), None)
+
+ def get_dummy_type(self):
+ return GENERIC_POINTER
+
+ def _compile_subroutine_no_cache(self, builder, impl, sig, locals={},
+ flags=None):
+ """
+ Invoke the compiler to compile a function to be used inside a
+ nopython function, but without generating code to call that
+ function.
+
+ Note this context's flags are not inherited.
+ """
+ # Compile
+ from numba.core import compiler
+
+ with global_compiler_lock:
+ codegen = self.codegen()
+ library = codegen.create_library(impl.__name__)
+ if flags is None:
+
+ cstk = targetconfig.ConfigStack()
+ flags = compiler.Flags()
+ if cstk:
+ tls_flags = cstk.top()
+ if tls_flags.is_set("nrt") and tls_flags.nrt:
+ flags.nrt = True
+
+ flags.no_compile = True
+ flags.no_cpython_wrapper = True
+ flags.no_cfunc_wrapper = True
+
+ cres = compiler.compile_internal(self.typing_context, self,
+ library,
+ impl, sig.args,
+ sig.return_type, flags,
+ locals=locals)
+
+ # Allow inlining the function inside callers.
+ self.active_code_library.add_linking_library(cres.library)
+ return cres
+
+ def compile_subroutine(self, builder, impl, sig, locals={}, flags=None,
+ caching=True):
+ """
+ Compile the function *impl* for the given *sig* (in nopython mode).
+ Return an instance of CompileResult.
+
+ If *caching* evaluates True, the function keeps the compiled function
+ for reuse in *.cached_internal_func*.
+ """
+ cache_key = (impl.__code__, sig, type(self.error_model))
+ if not caching:
+ cached = None
+ else:
+ if impl.__closure__:
+ # XXX This obviously won't work if a cell's value is
+ # unhashable.
+ cache_key += tuple(c.cell_contents for c in impl.__closure__)
+ cached = self.cached_internal_func.get(cache_key)
+ if cached is None:
+ cres = self._compile_subroutine_no_cache(builder, impl, sig,
+ locals=locals,
+ flags=flags)
+ self.cached_internal_func[cache_key] = cres
+
+ cres = self.cached_internal_func[cache_key]
+ # Allow inlining the function inside callers.
+ self.active_code_library.add_linking_library(cres.library)
+ return cres
+
+ def compile_internal(self, builder, impl, sig, args, locals={}):
+ """
+ Like compile_subroutine(), but also call the function with the given
+ *args*.
+ """
+ cres = self.compile_subroutine(builder, impl, sig, locals)
+ return self.call_internal(builder, cres.fndesc, sig, args)
+
+ def call_internal(self, builder, fndesc, sig, args):
+ """
+ Given the function descriptor of an internally compiled function,
+ emit a call to that function with the given arguments.
+ """
+ status, res = self.call_internal_no_propagate(builder, fndesc, sig, args)
+ with cgutils.if_unlikely(builder, status.is_error):
+ self.call_conv.return_status_propagate(builder, status)
+
+ res = imputils.fix_returning_optional(self, builder, sig, status, res)
+ return res
+
+ def call_internal_no_propagate(self, builder, fndesc, sig, args):
+ """Similar to `.call_internal()` but does not handle or propagate
+ the return status automatically.
+ """
+ # Add call to the generated function
+ llvm_mod = builder.module
+ fn = self.declare_function(llvm_mod, fndesc)
+ status, res = self.call_conv.call_function(builder, fn, sig.return_type,
+ sig.args, args)
+ return status, res
+
+ def call_unresolved(self, builder, name, sig, args):
+ """
+ Insert a function call to an unresolved symbol with the given *name*.
+
+ Note: this is used for recursive call.
+
+ In the mutual recursion case::
+
+ @njit
+ def foo():
+ ... # calls bar()
+
+ @njit
+ def bar():
+ ... # calls foo()
+
+ foo()
+
+ When foo() is called, the compilation of bar() is fully completed
+ (codegen'ed and loaded) before foo() is. Since MCJIT's eager compilation
+ doesn't allow loading modules with declare-only functions (which is
+ needed for foo() in bar()), the call_unresolved injects a global
+ variable that the "linker" can update even after the module is loaded by
+ MCJIT. The linker would allocate space for the global variable before
+ the bar() module is loaded. When later foo() module is defined, it will
+ update bar()'s reference to foo().
+
+ The legacy lazy JIT and the new ORC JIT would allow a declare-only
+ function be used in a module as long as it is defined by the time of its
+ first use.
+ """
+ # Insert an unresolved reference to the function being called.
+ codegen = self.codegen()
+ fnty = self.call_conv.get_function_type(sig.return_type, sig.args)
+ fn = codegen.insert_unresolved_ref(builder, fnty, name)
+ # Normal call sequence
+ status, res = self.call_conv.call_function(builder, fn, sig.return_type,
+ sig.args, args)
+ with cgutils.if_unlikely(builder, status.is_error):
+ self.call_conv.return_status_propagate(builder, status)
+
+ res = imputils.fix_returning_optional(self, builder, sig, status, res)
+ return res
+
+ def get_executable(self, func, fndesc, env):
+ raise NotImplementedError
+
+ def get_python_api(self, builder):
+ return PythonAPI(self, builder)
+
+ def sentry_record_alignment(self, rectyp, attr):
+ """
+ Assumes offset starts from a properly aligned location
+ """
+ if self.strict_alignment:
+ offset = rectyp.offset(attr)
+ elemty = rectyp.typeof(attr)
+ if isinstance(elemty, types.NestedArray):
+ # For a NestedArray we need to consider the data type of
+ # elements of the array for alignment, not the array structure
+ # itself
+ elemty = elemty.dtype
+ align = self.get_abi_alignment(self.get_data_type(elemty))
+ if offset % align:
+ msg = "{rec}.{attr} of type {type} is not aligned".format(
+ rec=rectyp, attr=attr, type=elemty)
+ raise errors.NumbaTypeError(msg)
+
+ def get_helper_class(self, typ, kind='value'):
+ """
+ Get a helper class for the given *typ*.
+ """
+ # XXX handle all types: complex, array, etc.
+ # XXX should it be a method on the model instead? this would allow a default kind...
+ return cgutils.create_struct_proxy(typ, kind)
+
+ def _make_helper(self, builder, typ, value=None, ref=None, kind='value'):
+ cls = self.get_helper_class(typ, kind)
+ return cls(self, builder, value=value, ref=ref)
+
+ def make_helper(self, builder, typ, value=None, ref=None):
+ """
+ Get a helper object to access the *typ*'s members,
+ for the given value or reference.
+ """
+ return self._make_helper(builder, typ, value, ref, kind='value')
+
+ def make_data_helper(self, builder, typ, ref=None):
+ """
+ As make_helper(), but considers the value as stored in memory,
+ rather than a live value.
+ """
+ return self._make_helper(builder, typ, ref=ref, kind='data')
+
+ def make_array(self, typ):
+ from numba.np import arrayobj
+ return arrayobj.make_array(typ)
+
+ def populate_array(self, arr, **kwargs):
+ """
+ Populate array structure.
+ """
+ from numba.np import arrayobj
+ return arrayobj.populate_array(arr, **kwargs)
+
+ def make_complex(self, builder, typ, value=None):
+ """
+ Get a helper object to access the given complex numbers' members.
+ """
+ assert isinstance(typ, types.Complex), typ
+ return self.make_helper(builder, typ, value)
+
+ def make_tuple(self, builder, typ, values):
+ """
+ Create a tuple of the given *typ* containing the *values*.
+ """
+ tup = self.get_constant_undef(typ)
+ for i, val in enumerate(values):
+ tup = builder.insert_value(tup, val, i)
+ return tup
+
+ def make_constant_array(self, builder, typ, ary):
+ """
+ Create an array structure reifying the given constant array.
+ A low-level contiguous array constant is created in the LLVM IR.
+ """
+ datatype = self.get_data_type(typ.dtype)
+ # don't freeze ary of non-contig or bigger than 1MB
+ size_limit = 10**6
+
+ if (self.allow_dynamic_globals and
+ (typ.layout not in 'FC' or ary.nbytes > size_limit)):
+ # get pointer from the ary
+ dataptr = ary.ctypes.data
+ data = self.add_dynamic_addr(builder, dataptr, info=str(type(dataptr)))
+ rt_addr = self.add_dynamic_addr(builder, id(ary), info=str(type(ary)))
+ else:
+ # Handle data: reify the flattened array in "C" or "F" order as a
+ # global array of bytes.
+ flat = ary.flatten(order=typ.layout)
+ # Note: we use `bytearray(flat.data)` instead of `bytearray(flat)` to
+ # workaround issue #1850 which is due to numpy issue #3147
+ consts = cgutils.create_constant_array(llvmir.IntType(8), bytearray(flat.data))
+ data = cgutils.global_constant(builder, ".const.array.data", consts)
+ # Ensure correct data alignment (issue #1933)
+ data.align = self.get_abi_alignment(datatype)
+ # No reference to parent ndarray
+ rt_addr = None
+
+ # Handle shape
+ llintp = self.get_value_type(types.intp)
+ shapevals = [self.get_constant(types.intp, s) for s in ary.shape]
+ cshape = cgutils.create_constant_array(llintp, shapevals)
+
+ # Handle strides
+ stridevals = [self.get_constant(types.intp, s) for s in ary.strides]
+ cstrides = cgutils.create_constant_array(llintp, stridevals)
+
+ # Create array structure
+ cary = self.make_array(typ)(self, builder)
+
+ intp_itemsize = self.get_constant(types.intp, ary.dtype.itemsize)
+ self.populate_array(cary,
+ data=builder.bitcast(data, cary.data.type),
+ shape=cshape,
+ strides=cstrides,
+ itemsize=intp_itemsize,
+ parent=rt_addr,
+ meminfo=None)
+
+ return cary._getvalue()
+
+ def add_dynamic_addr(self, builder, intaddr, info):
+ """
+ Returns dynamic address as a void pointer `i8*`.
+
+ Internally, a global variable is added to inform the lowerer about
+ the usage of dynamic addresses. Caching will be disabled.
+ """
+ assert self.allow_dynamic_globals, "dyn globals disabled in this target"
+ assert isinstance(intaddr, int), 'dyn addr not of int type'
+ mod = builder.module
+ llvoidptr = self.get_value_type(types.voidptr)
+ addr = self.get_constant(types.uintp, intaddr).inttoptr(llvoidptr)
+ # Use a unique name by embedding the address value
+ symname = 'numba.dynamic.globals.{:x}'.format(intaddr)
+ gv = cgutils.add_global_variable(mod, llvoidptr, symname)
+ # Use linkonce linkage to allow merging with other GV of the same name.
+ # And, avoid optimization from assuming its value.
+ gv.linkage = 'linkonce'
+ gv.initializer = addr
+ return builder.load(gv)
+
+ def get_abi_sizeof(self, ty):
+ """
+ Get the ABI size of LLVM type *ty*.
+ """
+ assert isinstance(ty, llvmir.Type), "Expected LLVM type"
+ return ty.get_abi_size(self.target_data)
+
+ def get_abi_alignment(self, ty):
+ """
+ Get the ABI alignment of LLVM type *ty*.
+ """
+ assert isinstance(ty, llvmir.Type), "Expected LLVM type"
+ return ty.get_abi_alignment(self.target_data)
+
+ def get_preferred_array_alignment(context, ty):
+ """
+ Get preferred array alignment for Numba type *ty*.
+ """
+ # AVX prefers 32-byte alignment
+ return 32
+
+ def post_lowering(self, mod, library):
+ """Run target specific post-lowering transformation here.
+ """
+
+ def create_module(self, name):
+ """Create a LLVM module
+
+ The default implementation in BaseContext always raises a
+ ``NotImplementedError`` exception. Subclasses should implement
+ this method.
+ """
+ raise NotImplementedError
+
+ @property
+ def active_code_library(self):
+ """Get the active code library
+ """
+ return self._codelib_stack[-1]
+
+ @contextmanager
+ def push_code_library(self, lib):
+ """Push the active code library for the context
+ """
+ self._codelib_stack.append(lib)
+ try:
+ yield
+ finally:
+ self._codelib_stack.pop()
+
+ def add_linking_libs(self, libs):
+ """Add iterable of linking libraries to the *active_code_library*.
+ """
+ colib = self.active_code_library
+ for lib in libs:
+ colib.add_linking_library(lib)
+
+ def get_ufunc_info(self, ufunc_key):
+ """Get the ufunc implementation for a given ufunc object.
+
+ The default implementation in BaseContext always raises a
+ ``NotImplementedError`` exception. Subclasses may raise ``KeyError``
+ to signal that the given ``ufunc_key`` is not available.
+
+ Parameters
+ ----------
+ ufunc_key : NumPy ufunc
+
+ Returns
+ -------
+ res : dict[str, callable]
+ A mapping of a NumPy ufunc type signature to a lower-level
+ implementation.
+ """
+ raise NotImplementedError(f"{self} does not support ufunc")
+
+class _wrap_impl(object):
+ """
+ A wrapper object to call an implementation function with some predefined
+ (context, signature) arguments.
+ The wrapper also forwards attribute queries, which is important.
+ """
+
+ def __init__(self, imp, context, sig):
+ self._callable = _wrap_missing_loc(imp)
+ self._imp = self._callable()
+ self._context = context
+ self._sig = sig
+
+ def __call__(self, builder, args, loc=None):
+ res = self._imp(self._context, builder, self._sig, args, loc=loc)
+ self._context.add_linking_libs(getattr(self, 'libs', ()))
+ return res
+
+ def __getattr__(self, item):
+ return getattr(self._imp, item)
+
+ def __repr__(self):
+ return "" % repr(self._callable)
+
+def _has_loc(fn):
+ """Does function *fn* take ``loc`` argument?
+ """
+ sig = utils.pysignature(fn)
+ return 'loc' in sig.parameters
+
+
+class _wrap_missing_loc(object):
+
+ def __init__(self, fn):
+ self.func = fn # store this to help with debug
+
+ def __call__(self):
+ """Wrap function for missing ``loc`` keyword argument.
+ Otherwise, return the original *fn*.
+ """
+ fn = self.func
+ if not _has_loc(fn):
+ def wrapper(*args, **kwargs):
+ kwargs.pop('loc') # drop unused loc
+ return fn(*args, **kwargs)
+
+ # Copy the following attributes from the wrapped.
+ # Following similar implementation as functools.wraps but
+ # ignore attributes if not available (i.e fix py2.7)
+ attrs = '__name__', 'libs'
+ for attr in attrs:
+ try:
+ val = getattr(fn, attr)
+ except AttributeError:
+ pass
+ else:
+ setattr(wrapper, attr, val)
+
+ return wrapper
+ else:
+ return fn
+
+ def __repr__(self):
+ return "" % self.func
+
+
+@utils.runonce
+def _initialize_llvm_lock_event():
+ """Initial event triggers for LLVM lock
+ """
+ def enter_fn():
+ event.start_event("numba:llvm_lock")
+
+ def exit_fn():
+ event.end_event("numba:llvm_lock")
+
+ ll.ffi.register_lock_callback(enter_fn, exit_fn)
+
+
+_initialize_llvm_lock_event()
diff --git a/venv/lib/python3.10/site-packages/numba/core/boxing.py b/venv/lib/python3.10/site-packages/numba/core/boxing.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e91c155b0d496e3dc2b4c8125939d6368c3ca90
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/boxing.py
@@ -0,0 +1,10 @@
+import sys
+from numba.core.utils import _RedirectSubpackage
+from numba.core import config
+
+if config.USE_LEGACY_TYPE_SYSTEM:
+ sys.modules[__name__] = _RedirectSubpackage(locals(),
+ "numba.core.old_boxing")
+else:
+ sys.modules[__name__] = _RedirectSubpackage(locals(),
+ "numba.core.new_boxing")
diff --git a/venv/lib/python3.10/site-packages/numba/core/bytecode.py b/venv/lib/python3.10/site-packages/numba/core/bytecode.py
new file mode 100644
index 0000000000000000000000000000000000000000..3df9c06bddfdfaeab7cd26938d68ebb2cebd048c
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/bytecode.py
@@ -0,0 +1,677 @@
+from collections import namedtuple, OrderedDict
+import dis
+import inspect
+import itertools
+
+from types import CodeType, ModuleType
+
+from numba.core import errors, utils, serialize
+from numba.core.utils import PYVERSION
+
+
+if PYVERSION in ((3, 12), (3, 13)):
+ from opcode import _inline_cache_entries
+ # Instruction/opcode length in bytes
+ INSTR_LEN = 2
+elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+else:
+ raise NotImplementedError(PYVERSION)
+
+
+opcode_info = namedtuple('opcode_info', ['argsize'])
+_ExceptionTableEntry = namedtuple("_ExceptionTableEntry",
+ "start end target depth lasti")
+
+# The following offset is used as a hack to inject a NOP at the start of the
+# bytecode. So that function starting with `while True` will not have block-0
+# as a jump target. The Lowerer puts argument initialization at block-0.
+_FIXED_OFFSET = 2
+
+
+def get_function_object(obj):
+ """
+ Objects that wraps function should provide a "__numba__" magic attribute
+ that contains a name of an attribute that contains the actual python
+ function object.
+ """
+ attr = getattr(obj, "__numba__", None)
+ if attr:
+ return getattr(obj, attr)
+ return obj
+
+
+def get_code_object(obj):
+ "Shamelessly borrowed from llpython"
+ return getattr(obj, '__code__', getattr(obj, 'func_code', None))
+
+
+def _as_opcodes(seq):
+ lst = []
+ for s in seq:
+ c = dis.opmap.get(s)
+ if c is not None:
+ lst.append(c)
+ return lst
+
+
+JREL_OPS = frozenset(dis.hasjrel)
+JABS_OPS = frozenset(dis.hasjabs)
+JUMP_OPS = JREL_OPS | JABS_OPS
+TERM_OPS = frozenset(_as_opcodes(['RETURN_VALUE', 'RAISE_VARARGS']))
+EXTENDED_ARG = dis.EXTENDED_ARG
+HAVE_ARGUMENT = dis.HAVE_ARGUMENT
+
+
+class ByteCodeInst(object):
+ '''
+ Attributes
+ ----------
+ - offset:
+ byte offset of opcode
+ - opcode:
+ opcode integer value
+ - arg:
+ instruction arg
+ - lineno:
+ -1 means unknown
+ '''
+ __slots__ = 'offset', 'next', 'opcode', 'opname', 'arg', 'lineno'
+
+ def __init__(self, offset, opcode, arg, nextoffset):
+ self.offset = offset
+ self.next = nextoffset
+ self.opcode = opcode
+ self.opname = dis.opname[opcode]
+ self.arg = arg
+ self.lineno = -1 # unknown line number
+
+ @property
+ def is_jump(self):
+ return self.opcode in JUMP_OPS
+
+ @property
+ def is_terminator(self):
+ return self.opcode in TERM_OPS
+
+ def get_jump_target(self):
+ # With Python 3.10 the addressing of "bytecode" instructions has
+ # changed from using bytes to using 16-bit words instead. As a
+ # consequence the code to determine where a jump will lead had to be
+ # adapted.
+ # See also:
+ # https://bugs.python.org/issue26647
+ # https://bugs.python.org/issue27129
+ # https://github.com/python/cpython/pull/25069
+ assert self.is_jump
+ if PYVERSION in ((3, 13),):
+ if self.opcode in (dis.opmap[k]
+ for k in ["JUMP_BACKWARD",
+ "JUMP_BACKWARD_NO_INTERRUPT"]):
+ return self.next - (self.arg * 2)
+ elif PYVERSION in ((3, 12),):
+ if self.opcode in (dis.opmap[k]
+ for k in ["JUMP_BACKWARD"]):
+ return self.offset - (self.arg - 1) * 2
+ elif PYVERSION in ((3, 11), ):
+ if self.opcode in (dis.opmap[k]
+ for k in ("JUMP_BACKWARD",
+ "POP_JUMP_BACKWARD_IF_TRUE",
+ "POP_JUMP_BACKWARD_IF_FALSE",
+ "POP_JUMP_BACKWARD_IF_NONE",
+ "POP_JUMP_BACKWARD_IF_NOT_NONE",)):
+ return self.offset - (self.arg - 1) * 2
+ elif PYVERSION in ((3, 10),):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+ if self.opcode in JREL_OPS:
+ return self.next + self.arg * 2
+ else:
+ assert self.opcode in JABS_OPS
+ return self.arg * 2 - 2
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def __repr__(self):
+ return '%s(arg=%s, lineno=%d)' % (self.opname, self.arg, self.lineno)
+
+ @property
+ def block_effect(self):
+ """Effect of the block stack
+ Returns +1 (push), 0 (none) or -1 (pop)
+ """
+ if self.opname.startswith('SETUP_'):
+ return 1
+ elif self.opname == 'POP_BLOCK':
+ return -1
+ else:
+ return 0
+
+
+CODE_LEN = 1
+ARG_LEN = 1
+NO_ARG_LEN = 1
+
+OPCODE_NOP = dis.opname.index('NOP')
+
+
+if PYVERSION in ((3, 13),):
+
+ def _unpack_opargs(code):
+ buf = []
+ for i, start_offset, op, arg in dis._unpack_opargs(code):
+ buf.append((start_offset, op, arg))
+ for i, (start_offset, op, arg) in enumerate(buf):
+ if i + 1 < len(buf):
+ next_offset = buf[i + 1][0]
+ else:
+ next_offset = len(code)
+ yield (start_offset, op, arg, next_offset)
+
+elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+
+ # Adapted from Lib/dis.py
+ def _unpack_opargs(code):
+ """
+ Returns a 4-int-tuple of
+ (bytecode offset, opcode, argument, offset of next bytecode).
+ """
+ extended_arg = 0
+ n = len(code)
+ offset = i = 0
+ while i < n:
+ op = code[i]
+ i += CODE_LEN
+ if op >= HAVE_ARGUMENT:
+ arg = code[i] | extended_arg
+ for j in range(ARG_LEN):
+ arg |= code[i + j] << (8 * j)
+ i += ARG_LEN
+ if PYVERSION in ((3, 12),):
+ # Python 3.12 introduced cache slots. We need to account for
+ # cache slots when we determine the offset of the next
+ # opcode. The number of cache slots is specific to each
+ # opcode and can be looked up in the _inline_cache_entries
+ # dictionary.
+ i += _inline_cache_entries[op] * INSTR_LEN
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+ if op == EXTENDED_ARG:
+ # This is a deviation from what dis does...
+ # In python 3.11 it seems like EXTENDED_ARGs appear more
+ # often and are also used as jump targets. So as to not have
+ # to do "book keeping" for where EXTENDED_ARGs have been
+ # "skipped" they are replaced with NOPs so as to provide a
+ # legal jump target and also ensure that the bytecode
+ # offsets are correct.
+ yield (offset, OPCODE_NOP, arg, i)
+ extended_arg = arg << 8 * ARG_LEN
+ offset = i
+ continue
+ else:
+ arg = None
+ i += NO_ARG_LEN
+ if PYVERSION in ((3, 12),):
+ # Python 3.12 introduced cache slots. We need to account for
+ # cache slots when we determine the offset of the next
+ # opcode. The number of cache slots is specific to each
+ # opcode and can be looked up in the _inline_cache_entries
+ # dictionary.
+ i += _inline_cache_entries[op] * INSTR_LEN
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ extended_arg = 0
+ yield (offset, op, arg, i)
+ offset = i # Mark inst offset at first extended
+else:
+ raise NotImplementedError(PYVERSION)
+
+
+def _patched_opargs(bc_stream):
+ """Patch the bytecode stream.
+
+ - Adds a NOP bytecode at the start to avoid jump target being at the entry.
+ """
+ # Injected NOP
+ yield (0, OPCODE_NOP, None, _FIXED_OFFSET)
+ # Adjust bytecode offset for the rest of the stream
+ for offset, opcode, arg, nextoffset in bc_stream:
+ # If the opcode has an absolute jump target, adjust it.
+ if opcode in JABS_OPS:
+ arg += _FIXED_OFFSET
+ yield offset + _FIXED_OFFSET, opcode, arg, nextoffset + _FIXED_OFFSET
+
+
+class ByteCodeIter(object):
+ def __init__(self, code):
+ self.code = code
+ self.iter = iter(_patched_opargs(_unpack_opargs(self.code.co_code)))
+
+ def __iter__(self):
+ return self
+
+ def _fetch_opcode(self):
+ return next(self.iter)
+
+ def next(self):
+ offset, opcode, arg, nextoffset = self._fetch_opcode()
+ return offset, ByteCodeInst(offset=offset, opcode=opcode, arg=arg,
+ nextoffset=nextoffset)
+
+ __next__ = next
+
+ def read_arg(self, size):
+ buf = 0
+ for i in range(size):
+ _offset, byte = next(self.iter)
+ buf |= byte << (8 * i)
+ return buf
+
+
+class _ByteCode(object):
+ """
+ The decoded bytecode of a function, and related information.
+ """
+ __slots__ = ('func_id', 'co_names', 'co_varnames', 'co_consts',
+ 'co_cellvars', 'co_freevars', 'exception_entries',
+ 'table', 'labels')
+
+ def __init__(self, func_id):
+ code = func_id.code
+
+ labels = set(x + _FIXED_OFFSET for x in dis.findlabels(code.co_code))
+ labels.add(0)
+
+ # A map of {offset: ByteCodeInst}
+ table = OrderedDict(ByteCodeIter(code))
+ self._compute_lineno(table, code)
+
+ self.func_id = func_id
+ self.co_names = code.co_names
+ self.co_varnames = code.co_varnames
+ self.co_consts = code.co_consts
+ self.co_cellvars = code.co_cellvars
+ self.co_freevars = code.co_freevars
+
+ self.table = table
+ self.labels = sorted(labels)
+
+ @classmethod
+ def _compute_lineno(cls, table, code):
+ """
+ Compute the line numbers for all bytecode instructions.
+ """
+ for offset, lineno in dis.findlinestarts(code):
+ adj_offset = offset + _FIXED_OFFSET
+ if adj_offset in table:
+ table[adj_offset].lineno = lineno
+ # Assign unfilled lineno
+ # Start with first bytecode's lineno
+ known = code.co_firstlineno
+ for inst in table.values():
+ if inst.lineno is not None and inst.lineno >= 0:
+ known = inst.lineno
+ else:
+ inst.lineno = known
+ return table
+
+ def __iter__(self):
+ return iter(self.table.values())
+
+ def __getitem__(self, offset):
+ return self.table[offset]
+
+ def __contains__(self, offset):
+ return offset in self.table
+
+ def dump(self):
+ def label_marker(i):
+ if i[1].offset in self.labels:
+ return '>'
+ else:
+ return ' '
+
+ return '\n'.join('%s %10s\t%s' % ((label_marker(i),) + i)
+ for i in self.table.items()
+ if i[1].opname != "CACHE")
+
+ @classmethod
+ def _compute_used_globals(cls, func, table, co_consts, co_names):
+ """
+ Compute the globals used by the function with the given
+ bytecode table.
+ """
+ d = {}
+ globs = func.__globals__
+ builtins = globs.get('__builtins__', utils.builtins)
+ if isinstance(builtins, ModuleType):
+ builtins = builtins.__dict__
+ # Look for LOAD_GLOBALs in the bytecode
+ for inst in table.values():
+ if inst.opname == 'LOAD_GLOBAL':
+ name = co_names[_fix_LOAD_GLOBAL_arg(inst.arg)]
+ if name not in d:
+ try:
+ value = globs[name]
+ except KeyError:
+ value = builtins[name]
+ d[name] = value
+ # Add globals used by any nested code object
+ for co in co_consts:
+ if isinstance(co, CodeType):
+ subtable = OrderedDict(ByteCodeIter(co))
+ d.update(cls._compute_used_globals(func, subtable,
+ co.co_consts, co.co_names))
+ return d
+
+ def get_used_globals(self):
+ """
+ Get a {name: value} map of the globals used by this code
+ object and any nested code objects.
+ """
+ return self._compute_used_globals(self.func_id.func, self.table,
+ self.co_consts, self.co_names)
+
+
+def _fix_LOAD_GLOBAL_arg(arg):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ return arg >> 1
+ elif PYVERSION in ((3, 10),):
+ return arg
+ else:
+ raise NotImplementedError(PYVERSION)
+
+
+class ByteCodePy311(_ByteCode):
+
+ def __init__(self, func_id):
+ super().__init__(func_id)
+ entries = dis.Bytecode(func_id.code).exception_entries
+ self.exception_entries = tuple(map(self.fixup_eh, entries))
+
+ @staticmethod
+ def fixup_eh(ent):
+ # Patch up the exception table offset
+ # because we add a NOP in _patched_opargs
+ out = dis._ExceptionTableEntry(
+ start=ent.start + _FIXED_OFFSET, end=ent.end + _FIXED_OFFSET,
+ target=ent.target + _FIXED_OFFSET,
+ depth=ent.depth, lasti=ent.lasti,
+ )
+ return out
+
+ def find_exception_entry(self, offset):
+ """
+ Returns the exception entry for the given instruction offset
+ """
+ candidates = []
+ for ent in self.exception_entries:
+ if ent.start <= offset < ent.end:
+ candidates.append((ent.depth, ent))
+ if candidates:
+ ent = max(candidates)[1]
+ return ent
+
+
+class ByteCodePy312(ByteCodePy311):
+
+ def __init__(self, func_id):
+ super().__init__(func_id)
+
+ # initialize lazy property
+ self._ordered_offsets = None
+
+ # Fixup offsets for all exception entries.
+ entries = [self.fixup_eh(e) for e in
+ dis.Bytecode(func_id.code).exception_entries
+ ]
+
+ # Remove exceptions, innermost ones first
+ # Can be done by using a stack
+ entries = self.remove_build_list_swap_pattern(entries)
+
+ # If this is a generator, we need to skip any exception table entries
+ # that point to the exception handler with the highest offset.
+ if func_id.is_generator:
+ # Get the exception handler with the highest offset.
+ max_exception_target = max([e.target for e in entries])
+ # Remove any exception table entries that point to that exception
+ # handler.
+ entries = [e for e in entries if e.target != max_exception_target]
+
+ self.exception_entries = tuple(entries)
+
+ @property
+ def ordered_offsets(self):
+ if not self._ordered_offsets:
+ # Get an ordered list of offsets.
+ self._ordered_offsets = [o for o in self.table]
+ return self._ordered_offsets
+
+ def remove_build_list_swap_pattern(self, entries):
+ """ Find the following bytecode pattern:
+
+ BUILD_{LIST, MAP, SET}
+ SWAP(2)
+ FOR_ITER
+ ...
+ END_FOR
+ SWAP(2)
+
+ This pattern indicates that a list/dict/set comprehension has
+ been inlined. In this case we can skip the exception blocks
+ entirely along with the dead exceptions that it points to.
+ A pair of exception that sandwiches these exception will
+ also be merged into a single exception.
+
+ Update for Python 3.13, the ending of the pattern has a extra
+ POP_TOP:
+
+ ...
+ END_FOR
+ POP_TOP
+ SWAP(2)
+
+ Update for Python 3.13.1, there's now a GET_ITER before FOR_ITER.
+ This patch the GET_ITER to NOP to minimize changes downstream
+ (e.g. array-comprehension).
+ """
+ def pop_and_merge_exceptions(entries: list,
+ entry_to_remove: _ExceptionTableEntry):
+ lower_entry_idx = entries.index(entry_to_remove) - 1
+ upper_entry_idx = entries.index(entry_to_remove) + 1
+
+ # Merge the upper and lower exceptions if possible.
+ if lower_entry_idx >= 0 and upper_entry_idx < len(entries):
+ lower_entry = entries[lower_entry_idx]
+ upper_entry = entries[upper_entry_idx]
+ if lower_entry.target == upper_entry.target:
+ entries[lower_entry_idx] = _ExceptionTableEntry(
+ lower_entry.start,
+ upper_entry.end,
+ lower_entry.target,
+ lower_entry.depth,
+ upper_entry.lasti)
+ entries.remove(upper_entry)
+
+ # Remove the exception entry.
+ entries.remove(entry_to_remove)
+ # Remove dead exceptions, if any, that the entry above may point to.
+ entries = [e for e in entries
+ if not e.start == entry_to_remove.target]
+ return entries
+
+ change_to_nop = set()
+ work_remaining = True
+ while work_remaining:
+ # Temporarily set work_remaining to False, if we find a pattern
+ # then work is not complete, hence we set it again to True.
+ work_remaining = False
+ current_nop_fixes = set()
+ for entry in entries.copy():
+ # Check start of pattern, three instructions.
+ # Work out the index of the instruction.
+ index = self.ordered_offsets.index(entry.start)
+ # If there is a BUILD_{LIST, MAP, SET} instruction at this
+ # location.
+ curr_inst = self.table[self.ordered_offsets[index]]
+ if curr_inst.opname not in ("BUILD_LIST",
+ "BUILD_MAP",
+ "BUILD_SET"):
+ continue
+ # Check if the BUILD_{LIST, MAP, SET} instruction is followed
+ # by a SWAP(2).
+ next_inst = self.table[self.ordered_offsets[index + 1]]
+ if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+ continue
+ next_inst = self.table[self.ordered_offsets[index + 2]]
+ # Check if the SWAP is followed by a FOR_ITER
+ # BUT Python3.13.1 introduced an extra GET_ITER.
+ # If we see a GET_ITER here, check if the next thing is a
+ # FOR_ITER.
+ if next_inst.opname == "GET_ITER":
+ # Add the inst to potentially be replaced to NOP
+ current_nop_fixes.add(next_inst)
+ # Loop up next instruction.
+ next_inst = self.table[self.ordered_offsets[index + 3]]
+
+ if not next_inst.opname == "FOR_ITER":
+ continue
+
+ if PYVERSION in ((3, 13),):
+ # Check end of pattern, two instructions.
+ # Check for the corresponding END_FOR, exception table end
+ # is non-inclusive, so subtract one.
+ index = self.ordered_offsets.index(entry.end)
+ curr_inst = self.table[self.ordered_offsets[index - 2]]
+ if not curr_inst.opname == "END_FOR":
+ continue
+ next_inst = self.table[self.ordered_offsets[index - 1]]
+ if not next_inst.opname == "POP_TOP":
+ continue
+ # END_FOR must be followed by SWAP(2)
+ next_inst = self.table[self.ordered_offsets[index]]
+ if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+ continue
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ # Check end of pattern, two instructions.
+ # Check for the corresponding END_FOR, exception table end
+ # is non-inclusive, so subtract one.
+ index = self.ordered_offsets.index(entry.end)
+ curr_inst = self.table[self.ordered_offsets[index - 1]]
+ if not curr_inst.opname == "END_FOR":
+ continue
+ # END_FOR must be followed by SWAP(2)
+ next_inst = self.table[self.ordered_offsets[index]]
+ if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+ continue
+ else:
+ raise NotImplementedError(PYVERSION)
+ # If all conditions are met that means this exception entry
+ # is for a list/dict/set comprehension and can be removed.
+ # Also if there exist exception entries above and below this
+ # entry pointing to the same target. those can be merged into
+ # a single bigger exception block.
+ entries = pop_and_merge_exceptions(entries, entry)
+ work_remaining = True
+
+ # Commit NOP fixes since we confirmed the suspects belong to
+ # a comprehension code.
+ change_to_nop |= current_nop_fixes
+
+ # Complete fixes to NOPs
+ for inst in change_to_nop:
+ self.table[inst.offset] = ByteCodeInst(inst.offset,
+ dis.opmap["NOP"],
+ None,
+ inst.next)
+ return entries
+
+
+if PYVERSION == (3, 11):
+ ByteCode = ByteCodePy311
+elif PYVERSION in ((3, 12), (3, 13),):
+ ByteCode = ByteCodePy312
+elif PYVERSION < (3, 11):
+ ByteCode = _ByteCode
+else:
+ raise NotImplementedError(PYVERSION)
+
+
+class FunctionIdentity(serialize.ReduceMixin):
+ """
+ A function's identity and metadata.
+
+ Note this typically represents a function whose bytecode is
+ being compiled, not necessarily the top-level user function
+ (the two might be distinct).
+ """
+ _unique_ids = itertools.count(1)
+
+ @classmethod
+ def from_function(cls, pyfunc):
+ """
+ Create the FunctionIdentity of the given function.
+ """
+ func = get_function_object(pyfunc)
+ code = get_code_object(func)
+ pysig = utils.pysignature(func)
+ if not code:
+ raise errors.ByteCodeSupportError(
+ "%s does not provide its bytecode" % func)
+
+ try:
+ func_qualname = func.__qualname__
+ except AttributeError:
+ func_qualname = func.__name__
+
+ self = cls()
+ self.func = func
+ self.func_qualname = func_qualname
+ self.func_name = func_qualname.split('.')[-1]
+ self.code = code
+ self.module = inspect.getmodule(func)
+ self.modname = (utils._dynamic_modname
+ if self.module is None
+ else self.module.__name__)
+ self.is_generator = inspect.isgeneratorfunction(func)
+ self.pysig = pysig
+ self.filename = code.co_filename
+ self.firstlineno = code.co_firstlineno
+ self.arg_count = len(pysig.parameters)
+ self.arg_names = list(pysig.parameters)
+
+ # Even the same function definition can be compiled into
+ # several different function objects with distinct closure
+ # variables, so we make sure to disambiguate using an unique id.
+ uid = next(cls._unique_ids)
+ self.unique_name = '{}${}'.format(self.func_qualname, uid)
+ self.unique_id = uid
+
+ return self
+
+ def derive(self):
+ """Copy the object and increment the unique counter.
+ """
+ return self.from_function(self.func)
+
+ def _reduce_states(self):
+ """
+ NOTE: part of ReduceMixin protocol
+ """
+ return dict(pyfunc=self.func)
+
+ @classmethod
+ def _rebuild(cls, pyfunc):
+ """
+ NOTE: part of ReduceMixin protocol
+ """
+ return cls.from_function(pyfunc)
diff --git a/venv/lib/python3.10/site-packages/numba/core/byteflow.py b/venv/lib/python3.10/site-packages/numba/core/byteflow.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e344999c67d3e9476fb1ce89135fd53c415d0a9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/byteflow.py
@@ -0,0 +1,2222 @@
+"""
+Implement python 3.8+ bytecode analysis
+"""
+import dis
+import logging
+from collections import namedtuple, defaultdict, deque
+from functools import total_ordering
+
+from numba.core.utils import (UniqueDict, PYVERSION, ALL_BINOPS_TO_OPERATORS,
+ _lazy_pformat)
+from numba.core.controlflow import NEW_BLOCKERS, CFGraph
+from numba.core.ir import Loc
+from numba.core.errors import UnsupportedBytecodeError
+
+
+_logger = logging.getLogger(__name__)
+
+_EXCEPT_STACK_OFFSET = 6
+_FINALLY_POP = _EXCEPT_STACK_OFFSET
+_NO_RAISE_OPS = frozenset({
+ 'LOAD_CONST',
+ 'NOP',
+ 'LOAD_DEREF',
+ 'PRECALL',
+})
+
+if PYVERSION in ((3, 12), (3, 13)):
+ from enum import Enum
+
+ # Operands for CALL_INTRINSIC_1
+ class CALL_INTRINSIC_1_Operand(Enum):
+ INTRINSIC_STOPITERATION_ERROR = 3
+ UNARY_POSITIVE = 5
+ INTRINSIC_LIST_TO_TUPLE = 6
+ ci1op = CALL_INTRINSIC_1_Operand
+elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+else:
+ raise NotImplementedError(PYVERSION)
+
+
+@total_ordering
+class BlockKind(object):
+ """Kinds of block to make related code safer than just `str`.
+ """
+ _members = frozenset({
+ 'LOOP',
+ 'TRY', 'EXCEPT', 'FINALLY',
+ 'WITH', 'WITH_FINALLY',
+ })
+
+ def __init__(self, value):
+ assert value in self._members
+ self._value = value
+
+ def __hash__(self):
+ return hash((type(self), self._value))
+
+ def __lt__(self, other):
+ if isinstance(other, BlockKind):
+ return self._value < other._value
+ else:
+ raise TypeError('cannot compare to {!r}'.format(type(other)))
+
+ def __eq__(self, other):
+ if isinstance(other, BlockKind):
+ return self._value == other._value
+ else:
+ raise TypeError('cannot compare to {!r}'.format(type(other)))
+
+ def __repr__(self):
+ return "BlockKind({})".format(self._value)
+
+
+class Flow(object):
+ """Data+Control Flow analysis.
+
+ Simulate execution to recover dataflow and controlflow information.
+ """
+ def __init__(self, bytecode):
+ _logger.debug("bytecode dump:\n%s", bytecode.dump())
+ self._bytecode = bytecode
+ self.block_infos = UniqueDict()
+
+ def run(self):
+ """Run a trace over the bytecode over all reachable path.
+
+ The trace starts at bytecode offset 0 and gathers stack and control-
+ flow information by partially interpreting each bytecode.
+ Each ``State`` instance in the trace corresponds to a basic-block.
+ The State instances forks when a jump instruction is encountered.
+ A newly forked state is then added to the list of pending states.
+ The trace ends when there are no more pending states.
+ """
+ firststate = State(bytecode=self._bytecode, pc=0, nstack=0,
+ blockstack=())
+ runner = TraceRunner(debug_filename=self._bytecode.func_id.filename)
+ runner.pending.append(firststate)
+
+ # Enforce unique-ness on initial PC to avoid re-entering the PC with
+ # a different stack-depth. We don't know if such a case is ever
+ # possible, but no such case has been encountered in our tests.
+ first_encounter = UniqueDict()
+ # Loop over each pending state at a initial PC.
+ # Each state is tracing a basic block
+ while runner.pending:
+ _logger.debug("pending: %s", runner.pending)
+ state = runner.pending.popleft()
+ if state not in runner.finished:
+ _logger.debug("stack: %s", state._stack)
+ _logger.debug("state.pc_initial: %s", state)
+ first_encounter[state.pc_initial] = state
+ # Loop over the state until it is terminated.
+ while True:
+ runner.dispatch(state)
+ # Terminated?
+ if state.has_terminated():
+ break
+ else:
+ if self._run_handle_exception(runner, state):
+ break
+
+ if self._is_implicit_new_block(state):
+ # check if this is a with...as, abort if so
+ self._guard_with_as(state)
+ # else split
+ state.split_new_block()
+ break
+ _logger.debug("end state. edges=%s", state.outgoing_edges)
+ runner.finished.add(state)
+ out_states = state.get_outgoing_states()
+ runner.pending.extend(out_states)
+
+ # Complete controlflow
+ self._build_cfg(runner.finished)
+ # Prune redundant PHI-nodes
+ self._prune_phis(runner)
+ # Post process
+ for state in sorted(runner.finished, key=lambda x: x.pc_initial):
+ self.block_infos[state.pc_initial] = si = adapt_state_infos(state)
+ _logger.debug("block_infos %s:\n%s", state, si)
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def _run_handle_exception(self, runner, state):
+ if not state.in_with() and (
+ state.has_active_try() and
+ state.get_inst().opname not in _NO_RAISE_OPS):
+ # Is in a *try* block
+ state.fork(pc=state.get_inst().next)
+ runner._adjust_except_stack(state)
+ return True
+ else:
+ state.advance_pc()
+
+ # Must the new PC be a new block?
+ if not state.in_with() and state.is_in_exception():
+ _logger.debug("3.11 exception %s PC=%s",
+ state.get_exception(), state._pc)
+ eh = state.get_exception()
+ eh_top = state.get_top_block('TRY')
+ if eh_top and eh_top['end'] == eh.target:
+ # Same exception
+ eh_block = None
+ else:
+ eh_block = state.make_block("TRY", end=eh.target)
+ eh_block['end_offset'] = eh.end
+ eh_block['stack_depth'] = eh.depth
+ eh_block['push_lasti'] = eh.lasti
+ state.fork(pc=state._pc, extra_block=eh_block)
+ return True
+ elif PYVERSION in ((3, 10),):
+ def _run_handle_exception(self, runner, state):
+ if (state.has_active_try() and
+ state.get_inst().opname not in _NO_RAISE_OPS):
+ # Is in a *try* block
+ state.fork(pc=state.get_inst().next)
+ tryblk = state.get_top_block('TRY')
+ state.pop_block_and_above(tryblk)
+ nstack = state.stack_depth
+ kwargs = {}
+ if nstack > tryblk['entry_stack']:
+ kwargs['npop'] = nstack - tryblk['entry_stack']
+ handler = tryblk['handler']
+ kwargs['npush'] = {
+ BlockKind('EXCEPT'): _EXCEPT_STACK_OFFSET,
+ BlockKind('FINALLY'): _FINALLY_POP
+ }[handler['kind']]
+ kwargs['extra_block'] = handler
+ state.fork(pc=tryblk['end'], **kwargs)
+ return True
+ else:
+ state.advance_pc()
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def _build_cfg(self, all_states):
+ graph = CFGraph()
+ for state in all_states:
+ b = state.pc_initial
+ graph.add_node(b)
+ for state in all_states:
+ for edge in state.outgoing_edges:
+ graph.add_edge(state.pc_initial, edge.pc, 0)
+ graph.set_entry_point(0)
+ graph.process()
+ self.cfgraph = graph
+
+ def _prune_phis(self, runner):
+ # Find phis that are unused in the local block
+ _logger.debug("Prune PHIs".center(60, '-'))
+
+ # Compute dataflow for used phis and propagate
+
+ # 1. Get used-phis for each block
+ # Map block to used_phis
+ def get_used_phis_per_state():
+ used_phis = defaultdict(set)
+ phi_set = set()
+ for state in runner.finished:
+ used = set(state._used_regs)
+ phis = set(state._phis)
+ used_phis[state] |= phis & used
+ phi_set |= phis
+ return used_phis, phi_set
+
+ # Find use-defs
+ def find_use_defs():
+ defmap = {}
+ phismap = defaultdict(set)
+ for state in runner.finished:
+ for phi, rhs in state._outgoing_phis.items():
+ if rhs not in phi_set:
+ # Is a definition
+ defmap[phi] = state
+ phismap[phi].add((rhs, state))
+ _logger.debug("defmap: %s", _lazy_pformat(defmap))
+ _logger.debug("phismap: %s", _lazy_pformat(phismap))
+ return defmap, phismap
+
+ def propagate_phi_map(phismap):
+ """An iterative dataflow algorithm to find the definition
+ (the source) of each PHI node.
+ """
+ blacklist = defaultdict(set)
+
+ while True:
+ changing = False
+ for phi, defsites in sorted(list(phismap.items())):
+ for rhs, state in sorted(list(defsites)):
+ if rhs in phi_set:
+ defsites |= phismap[rhs]
+ blacklist[phi].add((rhs, state))
+ to_remove = blacklist[phi]
+ if to_remove & defsites:
+ defsites -= to_remove
+ changing = True
+
+ _logger.debug("changing phismap: %s", _lazy_pformat(phismap))
+ if not changing:
+ break
+
+ def apply_changes(used_phis, phismap):
+ keep = {}
+ for state, used_set in used_phis.items():
+ for phi in used_set:
+ keep[phi] = phismap[phi]
+ _logger.debug("keep phismap: %s", _lazy_pformat(keep))
+ new_out = defaultdict(dict)
+ for phi in keep:
+ for rhs, state in keep[phi]:
+ new_out[state][phi] = rhs
+
+ _logger.debug("new_out: %s", _lazy_pformat(new_out))
+ for state in runner.finished:
+ state._outgoing_phis.clear()
+ state._outgoing_phis.update(new_out[state])
+
+ used_phis, phi_set = get_used_phis_per_state()
+ _logger.debug("Used_phis: %s", _lazy_pformat(used_phis))
+ defmap, phismap = find_use_defs()
+ propagate_phi_map(phismap)
+ apply_changes(used_phis, phismap)
+ _logger.debug("DONE Prune PHIs".center(60, '-'))
+
+ def _is_implicit_new_block(self, state):
+ inst = state.get_inst()
+
+ if inst.offset in self._bytecode.labels:
+ return True
+ elif inst.opname in NEW_BLOCKERS:
+ return True
+ else:
+ return False
+
+ def _guard_with_as(self, state):
+ """Checks if the next instruction after a SETUP_WITH is something other
+ than a POP_TOP, if it is something else it'll be some sort of store
+ which is not supported (this corresponds to `with CTXMGR as VAR(S)`)."""
+ current_inst = state.get_inst()
+ if current_inst.opname in {"SETUP_WITH", "BEFORE_WITH"}:
+ next_op = self._bytecode[current_inst.next].opname
+ if next_op != "POP_TOP":
+ msg = ("The 'with (context manager) as "
+ "(variable):' construct is not "
+ "supported.")
+ raise UnsupportedBytecodeError(msg)
+
+
+def _is_null_temp_reg(reg):
+ return reg.startswith("$null$")
+
+
+class TraceRunner(object):
+ """Trace runner contains the states for the trace and the opcode dispatch.
+ """
+ def __init__(self, debug_filename):
+ self.debug_filename = debug_filename
+ self.pending = deque()
+ self.finished = set()
+
+ def get_debug_loc(self, lineno):
+ return Loc(self.debug_filename, lineno)
+
+ def dispatch(self, state):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ if state._blockstack:
+ state: State
+ while state._blockstack:
+ topblk = state._blockstack[-1]
+ blk_end = topblk['end']
+ if blk_end is not None and blk_end <= state.pc_initial:
+ state._blockstack.pop()
+ else:
+ break
+ elif PYVERSION in ((3, 10),):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+ inst = state.get_inst()
+ if inst.opname != "CACHE":
+ _logger.debug("dispatch pc=%s, inst=%s", state._pc, inst)
+ _logger.debug("stack %s", state._stack)
+ fn = getattr(self, "op_{}".format(inst.opname), None)
+ if fn is not None:
+ fn(state, inst)
+ else:
+ msg = "Use of unsupported opcode (%s) found" % inst.opname
+ raise UnsupportedBytecodeError(msg,
+ loc=self.get_debug_loc(inst.lineno))
+
+ def _adjust_except_stack(self, state):
+ """
+ Adjust stack when entering an exception handler to match expectation
+ by the bytecode.
+ """
+ tryblk = state.get_top_block('TRY')
+ state.pop_block_and_above(tryblk)
+ nstack = state.stack_depth
+ kwargs = {}
+ expected_depth = tryblk['stack_depth']
+ if nstack > expected_depth:
+ # Pop extra item in the stack
+ kwargs['npop'] = nstack - expected_depth
+ # Set extra stack itemcount due to the exception values.
+ extra_stack = 1
+ if tryblk['push_lasti']:
+ extra_stack += 1
+ kwargs['npush'] = extra_stack
+ state.fork(pc=tryblk['end'], **kwargs)
+
+ def op_NOP(self, state, inst):
+ state.append(inst)
+
+ def op_RESUME(self, state, inst):
+ state.append(inst)
+
+ def op_CACHE(self, state, inst):
+ state.append(inst)
+
+ def op_PRECALL(self, state, inst):
+ state.append(inst)
+
+ def op_PUSH_NULL(self, state, inst):
+ state.push(state.make_null())
+ state.append(inst)
+
+ def op_RETURN_GENERATOR(self, state, inst):
+ # This impl doesn't follow what CPython does. CPython is hacking
+ # the frame stack in the interpreter. From usage, it always
+ # has a POP_TOP after it so we push a dummy value to the stack.
+ #
+ # Example bytecode:
+ # > 0 NOP(arg=None, lineno=80)
+ # 2 RETURN_GENERATOR(arg=None, lineno=80)
+ # 4 POP_TOP(arg=None, lineno=80)
+ # 6 RESUME(arg=0, lineno=80)
+ state.push(state.make_temp())
+ state.append(inst)
+
+ if PYVERSION in ((3, 13),):
+ def op_FORMAT_SIMPLE(self, state, inst):
+ assert PYVERSION == (3, 13)
+ value = state.pop()
+ strvar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, value=value, res=res, strvar=strvar)
+ state.push(res)
+
+ def op_FORMAT_VALUE(self, state, inst):
+ """
+ FORMAT_VALUE(flags): flags argument specifies format spec which is
+ not supported yet. Currently, we just call str() on the value.
+ Pops a value from stack and pushes results back.
+ Required for supporting f-strings.
+ https://docs.python.org/3/library/dis.html#opcode-FORMAT_VALUE
+ """
+ if inst.arg != 0:
+ msg = "format spec in f-strings not supported yet"
+ raise UnsupportedBytecodeError(msg,
+ loc=self.get_debug_loc(inst.lineno))
+ value = state.pop()
+ strvar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, value=value, res=res, strvar=strvar)
+ state.push(res)
+
+ def op_BUILD_STRING(self, state, inst):
+ """
+ BUILD_STRING(count): Concatenates count strings from the stack and
+ pushes the resulting string onto the stack.
+ Required for supporting f-strings.
+ https://docs.python.org/3/library/dis.html#opcode-BUILD_STRING
+ """
+ count = inst.arg
+ strings = list(reversed([state.pop() for _ in range(count)]))
+ # corner case: f""
+ if count == 0:
+ tmps = [state.make_temp()]
+ else:
+ tmps = [state.make_temp() for _ in range(count - 1)]
+ state.append(inst, strings=strings, tmps=tmps)
+ state.push(tmps[-1])
+
+ def op_POP_TOP(self, state, inst):
+ state.pop()
+
+ if PYVERSION in ((3, 13),):
+ def op_TO_BOOL(self, state, inst):
+ res = state.make_temp()
+ tos = state.pop()
+ state.append(inst, val=tos, res=res)
+ state.push(res)
+
+ elif PYVERSION < (3, 13):
+ pass
+
+ if PYVERSION in ((3, 13),):
+ def op_LOAD_GLOBAL(self, state, inst):
+ # Ordering of the global value and NULL is swapped in Py3.13
+ res = state.make_temp()
+ idx = inst.arg >> 1
+ state.append(inst, idx=idx, res=res)
+ state.push(res)
+ # ignoring the NULL
+ if inst.arg & 1:
+ state.push(state.make_null())
+ elif PYVERSION in ((3, 11), (3, 12)):
+ def op_LOAD_GLOBAL(self, state, inst):
+ res = state.make_temp()
+ idx = inst.arg >> 1
+ state.append(inst, idx=idx, res=res)
+ # ignoring the NULL
+ if inst.arg & 1:
+ state.push(state.make_null())
+ state.push(res)
+ elif PYVERSION in ((3, 10),):
+ def op_LOAD_GLOBAL(self, state, inst):
+ res = state.make_temp()
+ state.append(inst, res=res)
+ state.push(res)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_COPY_FREE_VARS(self, state, inst):
+ state.append(inst)
+
+ def op_MAKE_CELL(self, state, inst):
+ state.append(inst)
+
+ def op_LOAD_DEREF(self, state, inst):
+ res = state.make_temp()
+ state.append(inst, res=res)
+ state.push(res)
+
+ def op_LOAD_CONST(self, state, inst):
+ # append const index for interpreter to read the const value
+ res = state.make_temp("const") + f".{inst.arg}"
+ state.push(res)
+ state.append(inst, res=res)
+
+ def op_LOAD_ATTR(self, state, inst):
+ item = state.pop()
+ res = state.make_temp()
+ if PYVERSION in ((3, 13),):
+ state.push(res) # the attr
+ if inst.arg & 1:
+ state.push(state.make_null())
+ elif PYVERSION in ((3, 12),):
+ if inst.arg & 1:
+ state.push(state.make_null())
+ state.push(res)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ state.push(res)
+ else:
+ raise NotImplementedError(PYVERSION)
+ state.append(inst, item=item, res=res)
+
+ def op_LOAD_FAST(self, state, inst):
+ assert PYVERSION <= (3, 13)
+ if PYVERSION in ((3, 13), ):
+ try:
+ name = state.get_varname(inst)
+ except IndexError: # oparg is out of range
+ # Handle this like a LOAD_DEREF
+ # Assume MAKE_CELL and COPY_FREE_VARS has correctly setup the
+ # states.
+ # According to https://github.com/python/cpython/blob/9ac606080a0074cdf7589d9b7c9413a73e0ddf37/Objects/codeobject.c#L730C9-L759 # noqa E501
+ # localsplus is locals + cells + freevars
+ bc = state._bytecode
+ num_varnames = len(bc.co_varnames)
+ num_freevars = len(bc.co_freevars)
+ num_cellvars = len(bc.co_cellvars)
+ max_fast_local = num_cellvars + num_freevars
+ assert 0 <= inst.arg - num_varnames < max_fast_local
+ res = state.make_temp()
+ state.append(inst, res=res, as_load_deref=True)
+ state.push(res)
+ return
+ else:
+ name = state.get_varname(inst)
+ res = state.make_temp(name)
+ state.append(inst, res=res)
+ state.push(res)
+
+ if PYVERSION in ((3, 13),):
+ def op_LOAD_FAST_LOAD_FAST(self, state, inst):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+ name1 = state.get_varname_by_arg(oparg1)
+ name2 = state.get_varname_by_arg(oparg2)
+ res1 = state.make_temp(name1)
+ res2 = state.make_temp(name2)
+ state.append(inst, res1=res1, res2=res2)
+ state.push(res1)
+ state.push(res2)
+
+ def op_STORE_FAST_LOAD_FAST(self, state, inst):
+ oparg = inst.arg
+ # oparg1 = oparg >> 4 # not needed
+ oparg2 = oparg & 15
+ store_value = state.pop()
+ load_name = state.get_varname_by_arg(oparg2)
+ load_res = state.make_temp(load_name)
+ state.append(inst, store_value=store_value, load_res=load_res)
+ state.push(load_res)
+
+ def op_STORE_FAST_STORE_FAST(self, state, inst):
+ value1 = state.pop()
+ value2 = state.pop()
+ state.append(inst, value1=value1, value2=value2)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ op_LOAD_FAST_CHECK = op_LOAD_FAST
+ op_LOAD_FAST_AND_CLEAR = op_LOAD_FAST
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_DELETE_FAST(self, state, inst):
+ state.append(inst)
+
+ def op_DELETE_ATTR(self, state, inst):
+ target = state.pop()
+ state.append(inst, target=target)
+
+ def op_STORE_ATTR(self, state, inst):
+ target = state.pop()
+ value = state.pop()
+ state.append(inst, target=target, value=value)
+
+ def op_STORE_DEREF(self, state, inst):
+ value = state.pop()
+ state.append(inst, value=value)
+
+ def op_STORE_FAST(self, state, inst):
+ value = state.pop()
+ state.append(inst, value=value)
+
+ def op_SLICE_1(self, state, inst):
+ """
+ TOS = TOS1[TOS:]
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ res = state.make_temp()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos1,
+ start=tos,
+ res=res,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+ state.push(res)
+
+ def op_SLICE_2(self, state, inst):
+ """
+ TOS = TOS1[:TOS]
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ res = state.make_temp()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos1,
+ stop=tos,
+ res=res,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+ state.push(res)
+
+ def op_SLICE_3(self, state, inst):
+ """
+ TOS = TOS2[TOS1:TOS]
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ tos2 = state.pop()
+ res = state.make_temp()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ state.append(
+ inst,
+ base=tos2,
+ start=tos1,
+ stop=tos,
+ res=res,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ )
+ state.push(res)
+
+ def op_STORE_SLICE_0(self, state, inst):
+ """
+ TOS[:] = TOS1
+ """
+ tos = state.pop()
+ value = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos,
+ value=value,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+
+ def op_STORE_SLICE_1(self, state, inst):
+ """
+ TOS1[TOS:] = TOS2
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ value = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos1,
+ start=tos,
+ slicevar=slicevar,
+ value=value,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+
+ def op_STORE_SLICE_2(self, state, inst):
+ """
+ TOS1[:TOS] = TOS2
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ value = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos1,
+ stop=tos,
+ value=value,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+
+ def op_STORE_SLICE_3(self, state, inst):
+ """
+ TOS2[TOS1:TOS] = TOS3
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ tos2 = state.pop()
+ value = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ state.append(
+ inst,
+ base=tos2,
+ start=tos1,
+ stop=tos,
+ value=value,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ )
+
+ def op_DELETE_SLICE_0(self, state, inst):
+ """
+ del TOS[:]
+ """
+ tos = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst, base=tos, slicevar=slicevar, indexvar=indexvar,
+ nonevar=nonevar,
+ )
+
+ def op_DELETE_SLICE_1(self, state, inst):
+ """
+ del TOS1[TOS:]
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos1,
+ start=tos,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+
+ def op_DELETE_SLICE_2(self, state, inst):
+ """
+ del TOS1[:TOS]
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ nonevar = state.make_temp()
+ state.append(
+ inst,
+ base=tos1,
+ stop=tos,
+ slicevar=slicevar,
+ indexvar=indexvar,
+ nonevar=nonevar,
+ )
+
+ def op_DELETE_SLICE_3(self, state, inst):
+ """
+ del TOS2[TOS1:TOS]
+ """
+ tos = state.pop()
+ tos1 = state.pop()
+ tos2 = state.pop()
+ slicevar = state.make_temp()
+ indexvar = state.make_temp()
+ state.append(
+ inst, base=tos2, start=tos1, stop=tos, slicevar=slicevar,
+ indexvar=indexvar
+ )
+
+ def op_BUILD_SLICE(self, state, inst):
+ """
+ slice(TOS1, TOS) or slice(TOS2, TOS1, TOS)
+ """
+ argc = inst.arg
+ if argc == 2:
+ tos = state.pop()
+ tos1 = state.pop()
+ start = tos1
+ stop = tos
+ step = None
+ elif argc == 3:
+ tos = state.pop()
+ tos1 = state.pop()
+ tos2 = state.pop()
+ start = tos2
+ stop = tos1
+ step = tos
+ else:
+ raise Exception("unreachable")
+ slicevar = state.make_temp()
+ res = state.make_temp()
+ state.append(
+ inst, start=start, stop=stop, step=step, res=res, slicevar=slicevar
+ )
+ state.push(res)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_BINARY_SLICE(self, state, inst):
+ end = state.pop()
+ start = state.pop()
+ container = state.pop()
+ temp_res = state.make_temp()
+ res = state.make_temp()
+ slicevar = state.make_temp()
+ state.append(
+ inst, start=start, end=end, container=container, res=res,
+ slicevar=slicevar, temp_res=temp_res
+ )
+ state.push(res)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_STORE_SLICE(self, state, inst):
+ end = state.pop()
+ start = state.pop()
+ container = state.pop()
+ value = state.pop()
+
+ slicevar = state.make_temp()
+ res = state.make_temp()
+ state.append(
+ inst, start=start, end=end, container=container, value=value,
+ res=res, slicevar=slicevar,
+ )
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def _op_POP_JUMP_IF(self, state, inst):
+ pred = state.pop()
+ state.append(inst, pred=pred)
+
+ target_inst = inst.get_jump_target()
+ next_inst = inst.next
+ # if the next inst and the jump target are the same location, issue one
+ # fork else issue a fork for the next and the target.
+ state.fork(pc=next_inst)
+ if target_inst != next_inst:
+ state.fork(pc=target_inst)
+
+ op_POP_JUMP_IF_TRUE = _op_POP_JUMP_IF
+ op_POP_JUMP_IF_FALSE = _op_POP_JUMP_IF
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ op_POP_JUMP_IF_NONE = _op_POP_JUMP_IF
+ op_POP_JUMP_IF_NOT_NONE = _op_POP_JUMP_IF
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def _op_JUMP_IF_OR_POP(self, state, inst):
+ pred = state.get_tos()
+ state.append(inst, pred=pred)
+ state.fork(pc=inst.next, npop=1)
+ state.fork(pc=inst.get_jump_target())
+
+ op_JUMP_IF_FALSE_OR_POP = _op_JUMP_IF_OR_POP
+ op_JUMP_IF_TRUE_OR_POP = _op_JUMP_IF_OR_POP
+
+ def op_POP_JUMP_FORWARD_IF_NONE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_FORWARD_IF_NOT_NONE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_BACKWARD_IF_NONE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_BACKWARD_IF_NOT_NONE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_FORWARD_IF_FALSE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_FORWARD_IF_TRUE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_BACKWARD_IF_FALSE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_POP_JUMP_BACKWARD_IF_TRUE(self, state, inst):
+ self._op_POP_JUMP_IF(state, inst)
+
+ def op_JUMP_FORWARD(self, state, inst):
+ state.append(inst)
+ state.fork(pc=inst.get_jump_target())
+
+ def op_JUMP_BACKWARD(self, state, inst):
+ state.append(inst)
+ state.fork(pc=inst.get_jump_target())
+
+ op_JUMP_BACKWARD_NO_INTERRUPT = op_JUMP_BACKWARD
+
+ def op_JUMP_ABSOLUTE(self, state, inst):
+ state.append(inst)
+ state.fork(pc=inst.get_jump_target())
+
+ def op_BREAK_LOOP(self, state, inst):
+ # NOTE: bytecode removed since py3.8
+ end = state.get_top_block('LOOP')['end']
+ state.append(inst, end=end)
+ state.pop_block()
+ state.fork(pc=end)
+
+ def op_RETURN_VALUE(self, state, inst):
+ state.append(inst, retval=state.pop(), castval=state.make_temp())
+ state.terminate()
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_RETURN_CONST(self, state, inst):
+ res = state.make_temp("const")
+ state.append(inst, retval=res, castval=state.make_temp())
+ state.terminate()
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_YIELD_VALUE(self, state, inst):
+ val = state.pop()
+ res = state.make_temp()
+ state.append(inst, value=val, res=res)
+ state.push(res)
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_RAISE_VARARGS(self, state, inst):
+ if inst.arg == 0:
+ exc = None
+ # No re-raising within a try-except block.
+ # But we allow bare reraise.
+ if state.has_active_try():
+ raise UnsupportedBytecodeError(
+ "The re-raising of an exception is not yet supported.",
+ loc=self.get_debug_loc(inst.lineno),
+ )
+ elif inst.arg == 1:
+ exc = state.pop()
+ else:
+ raise ValueError("Multiple argument raise is not supported.")
+ state.append(inst, exc=exc)
+
+ if state.has_active_try():
+ self._adjust_except_stack(state)
+ else:
+ state.terminate()
+
+ elif PYVERSION in ((3, 10),):
+ def op_RAISE_VARARGS(self, state, inst):
+ in_exc_block = any([
+ state.get_top_block("EXCEPT") is not None,
+ state.get_top_block("FINALLY") is not None
+ ])
+ if inst.arg == 0:
+ exc = None
+ if in_exc_block:
+ raise UnsupportedBytecodeError(
+ "The re-raising of an exception is not yet supported.",
+ loc=self.get_debug_loc(inst.lineno),
+ )
+ elif inst.arg == 1:
+ exc = state.pop()
+ else:
+ raise ValueError("Multiple argument raise is not supported.")
+ state.append(inst, exc=exc)
+ state.terminate()
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_BEGIN_FINALLY(self, state, inst):
+ temps = []
+ for i in range(_EXCEPT_STACK_OFFSET):
+ tmp = state.make_temp()
+ temps.append(tmp)
+ state.push(tmp)
+ state.append(inst, temps=temps)
+
+ def op_END_FINALLY(self, state, inst):
+ blk = state.pop_block()
+ state.reset_stack(blk['entry_stack'])
+
+ if PYVERSION in ((3, 13),):
+ def op_END_FOR(self, state, inst):
+ state.pop()
+ elif PYVERSION in ((3, 12),):
+ def op_END_FOR(self, state, inst):
+ state.pop()
+ state.pop()
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_POP_FINALLY(self, state, inst):
+ # we don't emulate the exact stack behavior
+ if inst.arg != 0:
+ msg = ('Unsupported use of a bytecode related to try..finally'
+ ' or a with-context')
+ raise UnsupportedBytecodeError(msg,
+ loc=self.get_debug_loc(inst.lineno))
+
+ def op_CALL_FINALLY(self, state, inst):
+ pass
+
+ def op_WITH_EXCEPT_START(self, state, inst):
+ state.terminate() # do not support
+
+ def op_WITH_CLEANUP_START(self, state, inst):
+ # we don't emulate the exact stack behavior
+ state.append(inst)
+
+ def op_WITH_CLEANUP_FINISH(self, state, inst):
+ # we don't emulate the exact stack behavior
+ state.append(inst)
+
+ def op_SETUP_LOOP(self, state, inst):
+ # NOTE: bytecode removed since py3.8
+ state.push_block(
+ state.make_block(
+ kind='LOOP',
+ end=inst.get_jump_target(),
+ )
+ )
+
+ def op_BEFORE_WITH(self, state, inst):
+ # Almost the same as py3.10 SETUP_WITH just lacking the finally block.
+ cm = state.pop() # the context-manager
+
+ yielded = state.make_temp()
+ exitfn = state.make_temp(prefix='setup_with_exitfn')
+
+ state.push(exitfn)
+ state.push(yielded)
+
+ # Gather all exception entries for this WITH. There maybe multiple
+ # entries; esp. for nested WITHs.
+ bc = state._bytecode
+ ehhead = bc.find_exception_entry(inst.next)
+ ehrelated = [ehhead]
+ for eh in bc.exception_entries:
+ if eh.target == ehhead.target:
+ ehrelated.append(eh)
+ end = max(eh.end for eh in ehrelated)
+ state.append(inst, contextmanager=cm, exitfn=exitfn, end=end)
+
+ state.push_block(
+ state.make_block(
+ kind='WITH',
+ end=end,
+ )
+ )
+ # Forces a new block
+ state.fork(pc=inst.next)
+
+ def op_SETUP_WITH(self, state, inst):
+ cm = state.pop() # the context-manager
+
+ yielded = state.make_temp()
+ exitfn = state.make_temp(prefix='setup_with_exitfn')
+ state.append(inst, contextmanager=cm, exitfn=exitfn)
+
+ state.push(exitfn)
+ state.push(yielded)
+
+ state.push_block(
+ state.make_block(
+ kind='WITH',
+ end=inst.get_jump_target(),
+ )
+ )
+ # Forces a new block
+ state.fork(pc=inst.next)
+
+ def _setup_try(self, kind, state, next, end):
+ # Forces a new block
+ # Fork to the body of the finally
+ handler_block = state.make_block(
+ kind=kind,
+ end=None,
+ reset_stack=False,
+ )
+ # Forces a new block
+ # Fork to the body of the finally
+ state.fork(
+ pc=next,
+ extra_block=state.make_block(
+ kind='TRY',
+ end=end,
+ reset_stack=False,
+ handler=handler_block,
+ )
+ )
+
+ def op_PUSH_EXC_INFO(self, state, inst):
+ tos = state.pop()
+ state.push(state.make_temp("exception"))
+ state.push(tos)
+
+ def op_SETUP_FINALLY(self, state, inst):
+ state.append(inst)
+ self._setup_try(
+ 'FINALLY', state, next=inst.next, end=inst.get_jump_target(),
+ )
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_POP_EXCEPT(self, state, inst):
+ state.pop()
+
+ elif PYVERSION in ((3, 10),):
+ def op_POP_EXCEPT(self, state, inst):
+ blk = state.pop_block()
+ if blk['kind'] not in {BlockKind('EXCEPT'), BlockKind('FINALLY')}:
+ raise UnsupportedBytecodeError(
+ f"POP_EXCEPT got an unexpected block: {blk['kind']}",
+ loc=self.get_debug_loc(inst.lineno),
+ )
+ state.pop()
+ state.pop()
+ state.pop()
+ # Forces a new block
+ state.fork(pc=inst.next)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_POP_BLOCK(self, state, inst):
+ blk = state.pop_block()
+ if blk['kind'] == BlockKind('TRY'):
+ state.append(inst, kind='try')
+ elif blk['kind'] == BlockKind('WITH'):
+ state.append(inst, kind='with')
+ state.fork(pc=inst.next)
+
+ def op_BINARY_SUBSCR(self, state, inst):
+ index = state.pop()
+ target = state.pop()
+ res = state.make_temp()
+ state.append(inst, index=index, target=target, res=res)
+ state.push(res)
+
+ def op_STORE_SUBSCR(self, state, inst):
+ index = state.pop()
+ target = state.pop()
+ value = state.pop()
+ state.append(inst, target=target, index=index, value=value)
+
+ def op_DELETE_SUBSCR(self, state, inst):
+ index = state.pop()
+ target = state.pop()
+ state.append(inst, target=target, index=index)
+
+ def op_CALL(self, state, inst):
+ narg = inst.arg
+ args = list(reversed([state.pop() for _ in range(narg)]))
+ if PYVERSION == (3, 13):
+ null_or_self = state.pop()
+ # position of the callable is fixed
+ callable = state.pop()
+ if not _is_null_temp_reg(null_or_self):
+ args = [null_or_self, *args]
+ kw_names = None
+ elif PYVERSION < (3, 13):
+ callable_or_firstarg = state.pop()
+ null_or_callable = state.pop()
+ if _is_null_temp_reg(null_or_callable):
+ callable = callable_or_firstarg
+ else:
+ callable = null_or_callable
+ args = [callable_or_firstarg, *args]
+ kw_names = state.pop_kw_names()
+ res = state.make_temp()
+
+ state.append(inst, func=callable, args=args, kw_names=kw_names, res=res)
+ state.push(res)
+
+ def op_KW_NAMES(self, state, inst):
+ state.set_kw_names(inst.arg)
+
+ def op_CALL_FUNCTION(self, state, inst):
+ narg = inst.arg
+ args = list(reversed([state.pop() for _ in range(narg)]))
+ func = state.pop()
+
+ res = state.make_temp()
+ state.append(inst, func=func, args=args, res=res)
+ state.push(res)
+
+ def op_CALL_FUNCTION_KW(self, state, inst):
+ narg = inst.arg
+ names = state.pop() # tuple of names
+ args = list(reversed([state.pop() for _ in range(narg)]))
+ func = state.pop()
+
+ res = state.make_temp()
+ state.append(inst, func=func, args=args, names=names, res=res)
+ state.push(res)
+
+ if PYVERSION in ((3, 13),):
+ def op_CALL_KW(self, state, inst):
+ narg = inst.arg
+ kw_names = state.pop()
+ args = list(reversed([state.pop() for _ in range(narg)]))
+ null_or_firstarg = state.pop()
+ callable = state.pop()
+ if not _is_null_temp_reg(null_or_firstarg):
+ args = [null_or_firstarg, *args]
+
+ res = state.make_temp()
+ state.append(inst, func=callable, args=args, kw_names=kw_names,
+ res=res)
+ state.push(res)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 13),):
+ def op_CALL_FUNCTION_EX(self, state, inst):
+ # (func, unused, callargs, kwargs if (oparg & 1) -- result))
+ if inst.arg & 1:
+ varkwarg = state.pop()
+ else:
+ varkwarg = None
+
+ vararg = state.pop()
+ state.pop() # unused
+ func = state.pop()
+
+ res = state.make_temp()
+ state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg,
+ res=res)
+ state.push(res)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+
+ def op_CALL_FUNCTION_EX(self, state, inst):
+ if inst.arg & 1:
+ varkwarg = state.pop()
+ else:
+ varkwarg = None
+ vararg = state.pop()
+ func = state.pop()
+
+ if PYVERSION in ((3, 11), (3, 12)):
+ if _is_null_temp_reg(state.peek(1)):
+ state.pop() # pop NULL, it's not used
+ elif PYVERSION in ((3, 10),):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ res = state.make_temp()
+ state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg,
+ res=res)
+ state.push(res)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def _dup_topx(self, state, inst, count):
+ orig = [state.pop() for _ in range(count)]
+ orig.reverse()
+ # We need to actually create new temporaries if we want the
+ # IR optimization pass to work correctly (see issue #580)
+ duped = [state.make_temp() for _ in range(count)]
+ state.append(inst, orig=orig, duped=duped)
+ for val in orig:
+ state.push(val)
+ for val in duped:
+ state.push(val)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_CALL_INTRINSIC_1(self, state, inst):
+ # See https://github.com/python/cpython/blob/v3.12.0rc2/Include/
+ # internal/pycore_intrinsics.h#L3-L17C36
+ try:
+ operand = CALL_INTRINSIC_1_Operand(inst.arg)
+ except TypeError:
+ msg = f"op_CALL_INTRINSIC_1({inst.arg})"
+ loc = self.get_debug_loc(inst.lineno)
+ raise UnsupportedBytecodeError(msg, loc=loc)
+ if operand == ci1op.INTRINSIC_STOPITERATION_ERROR:
+ state.append(inst, operand=operand)
+ state.terminate()
+ return
+ elif operand == ci1op.UNARY_POSITIVE:
+ val = state.pop()
+ res = state.make_temp()
+ state.append(inst, operand=operand,
+ value=val, res=res)
+ state.push(res)
+ return
+ elif operand == ci1op.INTRINSIC_LIST_TO_TUPLE:
+ tos = state.pop()
+ res = state.make_temp()
+ state.append(inst, operand=operand,
+ const_list=tos, res=res)
+ state.push(res)
+ return
+ else:
+ raise NotImplementedError(operand)
+
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_DUP_TOPX(self, state, inst):
+ count = inst.arg
+ assert 1 <= count <= 5, "Invalid DUP_TOPX count"
+ self._dup_topx(state, inst, count)
+
+ def op_DUP_TOP(self, state, inst):
+ self._dup_topx(state, inst, count=1)
+
+ def op_DUP_TOP_TWO(self, state, inst):
+ self._dup_topx(state, inst, count=2)
+
+ def op_COPY(self, state, inst):
+ state.push(state.peek(inst.arg))
+
+ def op_SWAP(self, state, inst):
+ state.swap(inst.arg)
+
+ def op_ROT_TWO(self, state, inst):
+ first = state.pop()
+ second = state.pop()
+ state.push(first)
+ state.push(second)
+
+ def op_ROT_THREE(self, state, inst):
+ first = state.pop()
+ second = state.pop()
+ third = state.pop()
+ state.push(first)
+ state.push(third)
+ state.push(second)
+
+ def op_ROT_FOUR(self, state, inst):
+ first = state.pop()
+ second = state.pop()
+ third = state.pop()
+ forth = state.pop()
+ state.push(first)
+ state.push(forth)
+ state.push(third)
+ state.push(second)
+
+ def op_UNPACK_SEQUENCE(self, state, inst):
+ count = inst.arg
+ iterable = state.pop()
+ stores = [state.make_temp() for _ in range(count)]
+ tupleobj = state.make_temp()
+ state.append(inst, iterable=iterable, stores=stores, tupleobj=tupleobj)
+ for st in reversed(stores):
+ state.push(st)
+
+ def op_BUILD_TUPLE(self, state, inst):
+ count = inst.arg
+ items = list(reversed([state.pop() for _ in range(count)]))
+ tup = state.make_temp()
+ state.append(inst, items=items, res=tup)
+ state.push(tup)
+
+ def _build_tuple_unpack(self, state, inst):
+ # Builds tuple from other tuples on the stack
+ tuples = list(reversed([state.pop() for _ in range(inst.arg)]))
+ temps = [state.make_temp() for _ in range(len(tuples) - 1)]
+
+ # if the unpack is assign-like, e.g. x = (*y,), it needs handling
+ # differently.
+ is_assign = len(tuples) == 1
+ if is_assign:
+ temps = [state.make_temp(),]
+
+ state.append(inst, tuples=tuples, temps=temps, is_assign=is_assign)
+ # The result is in the last temp var
+ state.push(temps[-1])
+
+ def op_BUILD_TUPLE_UNPACK_WITH_CALL(self, state, inst):
+ # just unpack the input tuple, call inst will be handled afterwards
+ self._build_tuple_unpack(state, inst)
+
+ def op_BUILD_TUPLE_UNPACK(self, state, inst):
+ self._build_tuple_unpack(state, inst)
+
+ def op_LIST_TO_TUPLE(self, state, inst):
+ # "Pops a list from the stack and pushes a tuple containing the same
+ # values."
+ tos = state.pop()
+ res = state.make_temp() # new tuple var
+ state.append(inst, const_list=tos, res=res)
+ state.push(res)
+
+ def op_BUILD_CONST_KEY_MAP(self, state, inst):
+ keys = state.pop()
+ vals = list(reversed([state.pop() for _ in range(inst.arg)]))
+ keytmps = [state.make_temp() for _ in range(inst.arg)]
+ res = state.make_temp()
+ state.append(inst, keys=keys, keytmps=keytmps, values=vals, res=res)
+ state.push(res)
+
+ def op_BUILD_LIST(self, state, inst):
+ count = inst.arg
+ items = list(reversed([state.pop() for _ in range(count)]))
+ lst = state.make_temp()
+ state.append(inst, items=items, res=lst)
+ state.push(lst)
+
+ def op_LIST_APPEND(self, state, inst):
+ value = state.pop()
+ index = inst.arg
+ target = state.peek(index)
+ appendvar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, target=target, value=value, appendvar=appendvar,
+ res=res)
+
+ def op_LIST_EXTEND(self, state, inst):
+ value = state.pop()
+ index = inst.arg
+ target = state.peek(index)
+ extendvar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, target=target, value=value, extendvar=extendvar,
+ res=res)
+
+ def op_BUILD_MAP(self, state, inst):
+ dct = state.make_temp()
+ count = inst.arg
+ items = []
+ # In 3.5+, BUILD_MAP takes pairs from the stack
+ for i in range(count):
+ v, k = state.pop(), state.pop()
+ items.append((k, v))
+ state.append(inst, items=items[::-1], size=count, res=dct)
+ state.push(dct)
+
+ def op_MAP_ADD(self, state, inst):
+ TOS = state.pop()
+ TOS1 = state.pop()
+ key, value = (TOS1, TOS)
+ index = inst.arg
+ target = state.peek(index)
+ setitemvar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, target=target, key=key, value=value,
+ setitemvar=setitemvar, res=res)
+
+ def op_BUILD_SET(self, state, inst):
+ count = inst.arg
+ # Note: related python bug http://bugs.python.org/issue26020
+ items = list(reversed([state.pop() for _ in range(count)]))
+ res = state.make_temp()
+ state.append(inst, items=items, res=res)
+ state.push(res)
+
+ def op_SET_UPDATE(self, state, inst):
+ value = state.pop()
+ index = inst.arg
+ target = state.peek(index)
+ updatevar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, target=target, value=value, updatevar=updatevar,
+ res=res)
+
+ def op_DICT_UPDATE(self, state, inst):
+ value = state.pop()
+ index = inst.arg
+ target = state.peek(index)
+ updatevar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, target=target, value=value, updatevar=updatevar,
+ res=res)
+
+ def op_GET_ITER(self, state, inst):
+ value = state.pop()
+ res = state.make_temp()
+ state.append(inst, value=value, res=res)
+ state.push(res)
+
+ def op_FOR_ITER(self, state, inst):
+ iterator = state.get_tos()
+ pair = state.make_temp()
+ indval = state.make_temp()
+ pred = state.make_temp()
+ state.append(inst, iterator=iterator, pair=pair, indval=indval,
+ pred=pred)
+ state.push(indval)
+ end = inst.get_jump_target()
+ if PYVERSION in ((3, 12), (3, 13)):
+ # Changed in version 3.12: Up until 3.11 the iterator was
+ # popped when it was exhausted. Now this is handled using END_FOR
+ # op code.
+ state.fork(pc=end)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ state.fork(pc=end, npop=2)
+ else:
+ raise NotImplementedError(PYVERSION)
+ state.fork(pc=inst.next)
+
+ def op_GEN_START(self, state, inst):
+ """Pops TOS. If TOS was not None, raises an exception. The kind
+ operand corresponds to the type of generator or coroutine and
+ determines the error message. The legal kinds are 0 for generator,
+ 1 for coroutine, and 2 for async generator.
+
+ New in version 3.10.
+ """
+ # no-op in Numba
+ pass
+
+ def op_BINARY_OP(self, state, inst):
+ op = dis._nb_ops[inst.arg][1]
+ rhs = state.pop()
+ lhs = state.pop()
+ op_name = ALL_BINOPS_TO_OPERATORS[op].__name__
+ res = state.make_temp(prefix=f"binop_{op_name}")
+ state.append(inst, op=op, lhs=lhs, rhs=rhs, res=res)
+ state.push(res)
+
+ def _unaryop(self, state, inst):
+ val = state.pop()
+ res = state.make_temp()
+ state.append(inst, value=val, res=res)
+ state.push(res)
+
+ op_UNARY_NEGATIVE = _unaryop
+ op_UNARY_POSITIVE = _unaryop
+ op_UNARY_NOT = _unaryop
+ op_UNARY_INVERT = _unaryop
+
+ def _binaryop(self, state, inst):
+ rhs = state.pop()
+ lhs = state.pop()
+ res = state.make_temp()
+ state.append(inst, lhs=lhs, rhs=rhs, res=res)
+ state.push(res)
+
+ op_COMPARE_OP = _binaryop
+ op_IS_OP = _binaryop
+ op_CONTAINS_OP = _binaryop
+
+ op_INPLACE_ADD = _binaryop
+ op_INPLACE_SUBTRACT = _binaryop
+ op_INPLACE_MULTIPLY = _binaryop
+ op_INPLACE_DIVIDE = _binaryop
+ op_INPLACE_TRUE_DIVIDE = _binaryop
+ op_INPLACE_FLOOR_DIVIDE = _binaryop
+ op_INPLACE_MODULO = _binaryop
+ op_INPLACE_POWER = _binaryop
+ op_INPLACE_MATRIX_MULTIPLY = _binaryop
+
+ op_INPLACE_LSHIFT = _binaryop
+ op_INPLACE_RSHIFT = _binaryop
+ op_INPLACE_AND = _binaryop
+ op_INPLACE_OR = _binaryop
+ op_INPLACE_XOR = _binaryop
+
+ op_BINARY_ADD = _binaryop
+ op_BINARY_SUBTRACT = _binaryop
+ op_BINARY_MULTIPLY = _binaryop
+ op_BINARY_DIVIDE = _binaryop
+ op_BINARY_TRUE_DIVIDE = _binaryop
+ op_BINARY_FLOOR_DIVIDE = _binaryop
+ op_BINARY_MODULO = _binaryop
+ op_BINARY_POWER = _binaryop
+ op_BINARY_MATRIX_MULTIPLY = _binaryop
+
+ op_BINARY_LSHIFT = _binaryop
+ op_BINARY_RSHIFT = _binaryop
+ op_BINARY_AND = _binaryop
+ op_BINARY_OR = _binaryop
+ op_BINARY_XOR = _binaryop
+
+ def op_MAKE_FUNCTION(self, state, inst, MAKE_CLOSURE=False):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ # https://github.com/python/cpython/commit/2f180ce
+ # name set via co_qualname
+ name = None
+ elif PYVERSION in ((3, 10),):
+ name = state.pop()
+ else:
+ raise NotImplementedError(PYVERSION)
+ code = state.pop()
+ closure = annotations = kwdefaults = defaults = None
+ if PYVERSION in ((3, 13), ):
+ assert inst.arg is None
+ # SET_FUNCTION_ATTRIBUTE is responsible for setting
+ # closure, annotations, kwdefaults and defaults.
+ else:
+ if inst.arg & 0x8:
+ closure = state.pop()
+ if inst.arg & 0x4:
+ annotations = state.pop()
+ if inst.arg & 0x2:
+ kwdefaults = state.pop()
+ if inst.arg & 0x1:
+ defaults = state.pop()
+ res = state.make_temp()
+ state.append(
+ inst,
+ name=name,
+ code=code,
+ closure=closure,
+ annotations=annotations,
+ kwdefaults=kwdefaults,
+ defaults=defaults,
+ res=res,
+ )
+ state.push(res)
+
+ def op_SET_FUNCTION_ATTRIBUTE(self, state, inst):
+ assert PYVERSION in ((3, 13), )
+ make_func_stack = state.pop()
+ data = state.pop()
+ if inst.arg == 0x1:
+ # 0x01 a tuple of default values for positional-only and
+ # positional-or-keyword parameters in positional order
+ state.set_function_attribute(make_func_stack, defaults=data)
+ elif inst.arg & 0x2:
+ # 0x02 a tuple of strings containing parameters’ annotations
+ state.set_function_attribute(make_func_stack, kwdefaults=data)
+ elif inst.arg & 0x4:
+ # 0x04 a tuple of strings containing parameters’ annotations
+ state.set_function_attribute(make_func_stack, annotations=data)
+ elif inst.arg == 0x8:
+ # 0x08 a tuple containing cells for free variables, making a closure
+ state.set_function_attribute(make_func_stack, closure=data)
+ else:
+ raise AssertionError("unreachable")
+ state.push(make_func_stack)
+
+ def op_MAKE_CLOSURE(self, state, inst):
+ self.op_MAKE_FUNCTION(state, inst, MAKE_CLOSURE=True)
+
+ def op_LOAD_CLOSURE(self, state, inst):
+ res = state.make_temp()
+ state.append(inst, res=res)
+ state.push(res)
+
+ def op_LOAD_ASSERTION_ERROR(self, state, inst):
+ res = state.make_temp("assertion_error")
+ state.append(inst, res=res)
+ state.push(res)
+
+ def op_CHECK_EXC_MATCH(self, state, inst):
+ pred = state.make_temp("predicate")
+ tos = state.pop()
+ tos1 = state.get_tos()
+ state.append(inst, pred=pred, tos=tos, tos1=tos1)
+ state.push(pred)
+
+ def op_JUMP_IF_NOT_EXC_MATCH(self, state, inst):
+ # Tests whether the second value on the stack is an exception matching
+ # TOS, and jumps if it is not. Pops two values from the stack.
+ pred = state.make_temp("predicate")
+ tos = state.pop()
+ tos1 = state.pop()
+ state.append(inst, pred=pred, tos=tos, tos1=tos1)
+ state.fork(pc=inst.next)
+ state.fork(pc=inst.get_jump_target())
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_RERAISE(self, state, inst):
+ # This isn't handled, but the state is set up anyway
+ exc = state.pop()
+ if inst.arg != 0:
+ state.pop() # lasti
+ state.append(inst, exc=exc)
+
+ if state.has_active_try():
+ self._adjust_except_stack(state)
+ else:
+ state.terminate()
+
+ elif PYVERSION in ((3, 10),):
+ def op_RERAISE(self, state, inst):
+ # This isn't handled, but the state is set up anyway
+ exc = state.pop()
+ state.append(inst, exc=exc)
+ state.terminate()
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ # NOTE: Please see notes in `interpreter.py` surrounding the implementation
+ # of LOAD_METHOD and CALL_METHOD.
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ # LOAD_METHOD has become a pseudo-instruction in 3.12
+ pass
+ elif PYVERSION in ((3, 11), ):
+ def op_LOAD_METHOD(self, state, inst):
+ item = state.pop()
+ extra = state.make_null()
+ state.push(extra)
+ res = state.make_temp()
+ state.append(inst, item=item, res=res)
+ state.push(res)
+ elif PYVERSION in ((3, 10),):
+ def op_LOAD_METHOD(self, state, inst):
+ self.op_LOAD_ATTR(state, inst)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_CALL_METHOD(self, state, inst):
+ self.op_CALL_FUNCTION(state, inst)
+
+
+@total_ordering
+class _State(object):
+ """State of the trace
+ """
+ def __init__(self, bytecode, pc, nstack, blockstack, nullvals=()):
+ """
+ Parameters
+ ----------
+ bytecode : numba.bytecode.ByteCode
+ function bytecode
+ pc : int
+ program counter
+ nstack : int
+ stackdepth at entry
+ blockstack : Sequence[Dict]
+ A sequence of dictionary denoting entries on the blockstack.
+ """
+ self._bytecode = bytecode
+ self._pc_initial = pc
+ self._pc = pc
+ self._nstack_initial = nstack
+ self._stack = []
+ self._blockstack_initial = tuple(blockstack)
+ self._blockstack = list(blockstack)
+ self._temp_registers = []
+ self._insts = []
+ self._outedges = []
+ self._terminated = False
+ self._phis = {}
+ self._outgoing_phis = UniqueDict()
+ self._used_regs = set()
+ for i in range(nstack):
+ if i in nullvals:
+ phi = self.make_temp("null$")
+ else:
+ phi = self.make_temp("phi")
+ self._phis[phi] = i
+ self.push(phi)
+
+ def __repr__(self):
+ return "State(pc_initial={} nstack_initial={})".format(
+ self._pc_initial, self._nstack_initial
+ )
+
+ def get_identity(self):
+ return (self._pc_initial, self._nstack_initial)
+
+ def __hash__(self):
+ return hash(self.get_identity())
+
+ def __lt__(self, other):
+ return self.get_identity() < other.get_identity()
+
+ def __eq__(self, other):
+ return self.get_identity() == other.get_identity()
+
+ @property
+ def pc_initial(self):
+ """The starting bytecode offset of this State.
+ The PC given to the constructor.
+ """
+ return self._pc_initial
+
+ @property
+ def instructions(self):
+ """The list of instructions information as a 2-tuple of
+ ``(pc : int, register_map : Dict)``
+ """
+ return self._insts
+
+ @property
+ def outgoing_edges(self):
+ """The list of outgoing edges.
+
+ Returns
+ -------
+ edges : List[State]
+ """
+ return self._outedges
+
+ @property
+ def outgoing_phis(self):
+ """The dictionary of outgoing phi nodes.
+
+ The keys are the name of the PHI nodes.
+ The values are the outgoing states.
+ """
+ return self._outgoing_phis
+
+ @property
+ def blockstack_initial(self):
+ """A copy of the initial state of the blockstack
+ """
+ return self._blockstack_initial
+
+ @property
+ def stack_depth(self):
+ """The current size of the stack
+
+ Returns
+ -------
+ res : int
+ """
+ return len(self._stack)
+
+ def find_initial_try_block(self):
+ """Find the initial *try* block.
+ """
+ for blk in reversed(self._blockstack_initial):
+ if blk['kind'] == BlockKind('TRY'):
+ return blk
+
+ def has_terminated(self):
+ return self._terminated
+
+ def get_inst(self):
+ return self._bytecode[self._pc]
+
+ def advance_pc(self):
+ inst = self.get_inst()
+ self._pc = inst.next
+
+ def make_temp(self, prefix=""):
+ if not prefix:
+ name = "${prefix}{offset}{opname}.{tempct}".format(
+ prefix=prefix,
+ offset=self._pc,
+ opname=self.get_inst().opname.lower(),
+ tempct=len(self._temp_registers),
+ )
+ else:
+ name = "${prefix}{offset}.{tempct}".format(
+ prefix=prefix,
+ offset=self._pc,
+ tempct=len(self._temp_registers),
+ )
+
+ self._temp_registers.append(name)
+ return name
+
+ def append(self, inst, **kwargs):
+ """Append new inst"""
+ self._insts.append((inst.offset, kwargs))
+ self._used_regs |= set(_flatten_inst_regs(kwargs.values()))
+
+ def get_tos(self):
+ return self.peek(1)
+
+ def peek(self, k):
+ """Return the k'th element on the stack
+ """
+ return self._stack[-k]
+
+ def push(self, item):
+ """Push to stack"""
+ self._stack.append(item)
+
+ def pop(self):
+ """Pop the stack"""
+ return self._stack.pop()
+
+ def swap(self, idx):
+ """Swap stack[idx] with the tos"""
+ s = self._stack
+ s[-1], s[-idx] = s[-idx], s[-1]
+
+ def push_block(self, synblk):
+ """Push a block to blockstack
+ """
+ assert 'stack_depth' in synblk
+ self._blockstack.append(synblk)
+
+ def reset_stack(self, depth):
+ """Reset the stack to the given stack depth.
+ Returning the popped items.
+ """
+ self._stack, popped = self._stack[:depth], self._stack[depth:]
+ return popped
+
+ def make_block(self, kind, end, reset_stack=True, handler=None):
+ """Make a new block
+ """
+ d = {
+ 'kind': BlockKind(kind),
+ 'end': end,
+ 'entry_stack': len(self._stack),
+ }
+ if reset_stack:
+ d['stack_depth'] = len(self._stack)
+ else:
+ d['stack_depth'] = None
+ d['handler'] = handler
+ return d
+
+ def pop_block(self):
+ """Pop a block and unwind the stack
+ """
+ b = self._blockstack.pop()
+ self.reset_stack(b['stack_depth'])
+ return b
+
+ def pop_block_and_above(self, blk):
+ """Find *blk* in the blockstack and remove it and all blocks above it
+ from the stack.
+ """
+ idx = self._blockstack.index(blk)
+ assert 0 <= idx < len(self._blockstack)
+ self._blockstack = self._blockstack[:idx]
+
+ def get_top_block(self, kind):
+ """Find the first block that matches *kind*
+ """
+ kind = BlockKind(kind)
+ for bs in reversed(self._blockstack):
+ if bs['kind'] == kind:
+ return bs
+
+ def get_top_block_either(self, *kinds):
+ """Find the first block that matches *kind*
+ """
+ kinds = {BlockKind(kind) for kind in kinds}
+ for bs in reversed(self._blockstack):
+ if bs['kind'] in kinds:
+ return bs
+
+ def has_active_try(self):
+ """Returns a boolean indicating if the top-block is a *try* block
+ """
+ return self.get_top_block('TRY') is not None
+
+ def get_varname(self, inst):
+ """Get referenced variable name from the instruction's oparg
+ """
+ return self.get_varname_by_arg(inst.arg)
+
+ def get_varname_by_arg(self, oparg: int):
+ """Get referenced variable name from the oparg
+ """
+ return self._bytecode.co_varnames[oparg]
+
+ def terminate(self):
+ """Mark block as terminated
+ """
+ self._terminated = True
+
+ def fork(self, pc, npop=0, npush=0, extra_block=None):
+ """Fork the state
+ """
+ # Handle changes on the stack
+ stack = list(self._stack)
+ if npop:
+ assert 0 <= npop <= len(self._stack)
+ nstack = len(self._stack) - npop
+ stack = stack[:nstack]
+ if npush:
+ assert 0 <= npush
+ for i in range(npush):
+ stack.append(self.make_temp())
+ # Handle changes on the blockstack
+ blockstack = list(self._blockstack)
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ # pop expired block in destination pc
+ while blockstack:
+ top = blockstack[-1]
+ end = top.get('end_offset') or top['end']
+ if pc >= end:
+ blockstack.pop()
+ else:
+ break
+ elif PYVERSION in ((3, 10),):
+ pass # intentionally bypass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if extra_block:
+ blockstack.append(extra_block)
+ self._outedges.append(Edge(
+ pc=pc, stack=tuple(stack), npush=npush,
+ blockstack=tuple(blockstack),
+ ))
+ self.terminate()
+
+ def split_new_block(self):
+ """Split the state
+ """
+ self.fork(pc=self._pc)
+
+ def get_outgoing_states(self):
+ """Get states for each outgoing edges
+ """
+ # Should only call once
+ assert not self._outgoing_phis
+ ret = []
+ for edge in self._outedges:
+ state = State(bytecode=self._bytecode, pc=edge.pc,
+ nstack=len(edge.stack), blockstack=edge.blockstack,
+ nullvals=[i for i, v in enumerate(edge.stack)
+ if _is_null_temp_reg(v)])
+ ret.append(state)
+ # Map outgoing_phis
+ for phi, i in state._phis.items():
+ self._outgoing_phis[phi] = edge.stack[i]
+ return ret
+
+ def get_outgoing_edgepushed(self):
+ """
+ Returns
+ -------
+ Dict[int, int]
+ where keys are the PC
+ values are the edge-pushed stack values
+ """
+
+ return {edge.pc: tuple(edge.stack[-edge.npush:])
+ for edge in self._outedges}
+
+
+class StatePy311(_State):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._kw_names = None
+
+ def pop_kw_names(self):
+ out = self._kw_names
+ self._kw_names = None
+ return out
+
+ def set_kw_names(self, val):
+ assert self._kw_names is None
+ self._kw_names = val
+
+ def is_in_exception(self):
+ bc = self._bytecode
+ return bc.find_exception_entry(self._pc) is not None
+
+ def get_exception(self):
+ bc = self._bytecode
+ return bc.find_exception_entry(self._pc)
+
+ def in_with(self):
+ for ent in self._blockstack_initial:
+ if ent["kind"] == BlockKind("WITH"):
+ return True
+
+ def make_null(self):
+ return self.make_temp(prefix="null$")
+
+
+class StatePy313(StatePy311):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._make_func_attrs = defaultdict(dict)
+
+ def set_function_attribute(self, make_func_res, **kwargs):
+ self._make_func_attrs[make_func_res].update(kwargs)
+
+ def get_function_attributes(self, make_func_res):
+ return self._make_func_attrs[make_func_res]
+
+
+if PYVERSION in ((3, 13), ):
+ State = StatePy313
+elif PYVERSION in ((3, 11), (3, 12)):
+ State = StatePy311
+elif PYVERSION < (3, 11):
+ State = _State
+else:
+ raise NotImplementedError(PYVERSION)
+
+
+Edge = namedtuple("Edge", ["pc", "stack", "blockstack", "npush"])
+
+
+class AdaptDFA(object):
+ """Adapt Flow to the old DFA class expected by Interpreter
+ """
+ def __init__(self, flow):
+ self._flow = flow
+
+ @property
+ def infos(self):
+ return self._flow.block_infos
+
+
+AdaptBlockInfo = namedtuple(
+ "AdaptBlockInfo",
+ ["insts", "outgoing_phis", "blockstack", "active_try_block",
+ "outgoing_edgepushed"],
+)
+
+
+def adapt_state_infos(state):
+ def process_function_attributes(inst_pair):
+ offset, data = inst_pair
+ inst = state._bytecode[offset]
+ if inst.opname == "MAKE_FUNCTION":
+ data.update(state.get_function_attributes(data['res']))
+ return offset, data
+ if PYVERSION in ((3, 13), ):
+ insts = tuple(map(process_function_attributes, state.instructions))
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ insts = tuple(state.instructions)
+ else:
+ raise NotImplementedError(PYVERSION)
+ return AdaptBlockInfo(
+ insts=insts,
+ outgoing_phis=state.outgoing_phis,
+ blockstack=state.blockstack_initial,
+ active_try_block=state.find_initial_try_block(),
+ outgoing_edgepushed=state.get_outgoing_edgepushed(),
+ )
+
+
+def _flatten_inst_regs(iterable):
+ """Flatten an iterable of registers used in an instruction
+ """
+ for item in iterable:
+ if isinstance(item, str):
+ yield item
+ elif isinstance(item, (tuple, list)):
+ for x in _flatten_inst_regs(item):
+ yield x
+
+
+class AdaptCFA(object):
+ """Adapt Flow to the old CFA class expected by Interpreter
+ """
+ def __init__(self, flow):
+ self._flow = flow
+ self._blocks = {}
+ for offset, blockinfo in flow.block_infos.items():
+ self._blocks[offset] = AdaptCFBlock(blockinfo, offset)
+ backbone = self._flow.cfgraph.backbone()
+
+ graph = flow.cfgraph
+ # Find backbone
+ backbone = graph.backbone()
+ # Filter out in loop blocks (Assuming no other cyclic control blocks)
+ # This is to unavoid variables defined in loops being considered as
+ # function scope.
+ inloopblocks = set()
+ for b in self.blocks.keys():
+ if graph.in_loops(b):
+ inloopblocks.add(b)
+ self._backbone = backbone - inloopblocks
+
+ @property
+ def graph(self):
+ return self._flow.cfgraph
+
+ @property
+ def backbone(self):
+ return self._backbone
+
+ @property
+ def blocks(self):
+ return self._blocks
+
+ def iterliveblocks(self):
+ for b in sorted(self.blocks):
+ yield self.blocks[b]
+
+ def dump(self):
+ self._flow.cfgraph.dump()
+
+
+class AdaptCFBlock(object):
+ def __init__(self, blockinfo, offset):
+ self.offset = offset
+ self.body = tuple(i for i, _ in blockinfo.insts)
diff --git a/venv/lib/python3.10/site-packages/numba/core/caching.py b/venv/lib/python3.10/site-packages/numba/core/caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..26dacfb356a1932f44f80de3259738755ed6ed26
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/caching.py
@@ -0,0 +1,777 @@
+"""
+Caching mechanism for compiled functions.
+"""
+
+
+from abc import ABCMeta, abstractmethod, abstractproperty
+import contextlib
+import errno
+import hashlib
+import inspect
+import itertools
+import os
+import pickle
+import sys
+import tempfile
+import uuid
+import warnings
+
+from numba.misc.appdirs import AppDirs
+import zipfile
+from pathlib import Path
+
+import numba
+from numba.core.errors import NumbaWarning
+from numba.core.base import BaseContext
+from numba.core.codegen import CodeLibrary
+from numba.core.compiler import CompileResult
+from numba.core import config, compiler
+from numba.core.serialize import dumps
+
+
+def _cache_log(msg, *args):
+ if config.DEBUG_CACHE:
+ msg = msg % args
+ print(msg)
+
+
+class _Cache(metaclass=ABCMeta):
+
+ @abstractproperty
+ def cache_path(self):
+ """
+ The base filesystem path of this cache (for example its root folder).
+ """
+
+ @abstractmethod
+ def load_overload(self, sig, target_context):
+ """
+ Load an overload for the given signature using the target context.
+ The saved object must be returned if successful, None if not found
+ in the cache.
+ """
+
+ @abstractmethod
+ def save_overload(self, sig, data):
+ """
+ Save the overload for the given signature.
+ """
+
+ @abstractmethod
+ def enable(self):
+ """
+ Enable the cache.
+ """
+
+ @abstractmethod
+ def disable(self):
+ """
+ Disable the cache.
+ """
+
+ @abstractmethod
+ def flush(self):
+ """
+ Flush the cache.
+ """
+
+
+class NullCache(_Cache):
+ @property
+ def cache_path(self):
+ return None
+
+ def load_overload(self, sig, target_context):
+ pass
+
+ def save_overload(self, sig, cres):
+ pass
+
+ def enable(self):
+ pass
+
+ def disable(self):
+ pass
+
+ def flush(self):
+ pass
+
+
+class _CacheLocator(metaclass=ABCMeta):
+ """
+ A filesystem locator for caching a given function.
+ """
+
+ def ensure_cache_path(self):
+ path = self.get_cache_path()
+ os.makedirs(path, exist_ok=True)
+ # Ensure the directory is writable by trying to write a temporary file
+ tempfile.TemporaryFile(dir=path).close()
+
+ @abstractmethod
+ def get_cache_path(self):
+ """
+ Return the directory the function is cached in.
+ """
+
+ @abstractmethod
+ def get_source_stamp(self):
+ """
+ Get a timestamp representing the source code's freshness.
+ Can return any picklable Python object.
+ """
+
+ @abstractmethod
+ def get_disambiguator(self):
+ """
+ Get a string disambiguator for this locator's function.
+ It should allow disambiguating different but similarly-named functions.
+ """
+
+ @classmethod
+ def from_function(cls, py_func, py_file):
+ """
+ Create a locator instance for the given function located in the
+ given file.
+ """
+ raise NotImplementedError
+
+ @classmethod
+ def get_suitable_cache_subpath(cls, py_file):
+ """Given the Python file path, compute a suitable path inside the
+ cache directory.
+
+ This will reduce a file path that is too long, which can be a problem
+ on some operating system (i.e. Windows 7).
+ """
+ path = os.path.abspath(py_file)
+ subpath = os.path.dirname(path)
+ parentdir = os.path.split(subpath)[-1]
+ # Use SHA1 to reduce path length.
+ # Note: windows doesn't like long path.
+ hashed = hashlib.sha1(subpath.encode()).hexdigest()
+ # Retain parent directory name for easier debugging
+ return '_'.join([parentdir, hashed])
+
+
+class _SourceFileBackedLocatorMixin(object):
+ """
+ A cache locator mixin for functions which are backed by a well-known
+ Python source file.
+ """
+
+ def get_source_stamp(self):
+ if getattr(sys, 'frozen', False):
+ st = os.stat(sys.executable)
+ else:
+ st = os.stat(self._py_file)
+ # We use both timestamp and size as some filesystems only have second
+ # granularity.
+ return st.st_mtime, st.st_size
+
+ def get_disambiguator(self):
+ return str(self._lineno)
+
+ @classmethod
+ def from_function(cls, py_func, py_file):
+ if not os.path.exists(py_file):
+ # Perhaps a placeholder (e.g. "")
+ return
+ self = cls(py_func, py_file)
+ try:
+ self.ensure_cache_path()
+ except OSError:
+ # Cannot ensure the cache directory exists or is writable
+ return
+ return self
+
+
+class _UserProvidedCacheLocator(_SourceFileBackedLocatorMixin, _CacheLocator):
+ """
+ A locator that always point to the user provided directory in
+ `numba.config.CACHE_DIR`
+ """
+ def __init__(self, py_func, py_file):
+ self._py_file = py_file
+ self._lineno = py_func.__code__.co_firstlineno
+ cache_subpath = self.get_suitable_cache_subpath(py_file)
+ self._cache_path = os.path.join(config.CACHE_DIR, cache_subpath)
+
+ def get_cache_path(self):
+ return self._cache_path
+
+ @classmethod
+ def from_function(cls, py_func, py_file):
+ if not config.CACHE_DIR:
+ return
+ parent = super(_UserProvidedCacheLocator, cls)
+ return parent.from_function(py_func, py_file)
+
+
+class _InTreeCacheLocator(_SourceFileBackedLocatorMixin, _CacheLocator):
+ """
+ A locator for functions backed by a regular Python module with a
+ writable __pycache__ directory.
+ """
+
+ def __init__(self, py_func, py_file):
+ self._py_file = py_file
+ self._lineno = py_func.__code__.co_firstlineno
+ self._cache_path = os.path.join(os.path.dirname(self._py_file), '__pycache__')
+
+ def get_cache_path(self):
+ return self._cache_path
+
+
+class _UserWideCacheLocator(_SourceFileBackedLocatorMixin, _CacheLocator):
+ """
+ A locator for functions backed by a regular Python module or a
+ frozen executable, cached into a user-wide cache directory.
+ """
+
+ def __init__(self, py_func, py_file):
+ self._py_file = py_file
+ self._lineno = py_func.__code__.co_firstlineno
+ appdirs = AppDirs(appname="numba", appauthor=False)
+ cache_dir = appdirs.user_cache_dir
+ cache_subpath = self.get_suitable_cache_subpath(py_file)
+ self._cache_path = os.path.join(cache_dir, cache_subpath)
+
+ def get_cache_path(self):
+ return self._cache_path
+
+ @classmethod
+ def from_function(cls, py_func, py_file):
+ if not (os.path.exists(py_file) or getattr(sys, 'frozen', False)):
+ # Perhaps a placeholder (e.g. "")
+ # stop function exit if frozen, since it uses a temp placeholder
+ return
+ self = cls(py_func, py_file)
+ try:
+ self.ensure_cache_path()
+ except OSError:
+ # Cannot ensure the cache directory exists or is writable
+ return
+ return self
+
+
+class _IPythonCacheLocator(_CacheLocator):
+ """
+ A locator for functions entered at the IPython prompt (notebook or other).
+ """
+
+ def __init__(self, py_func, py_file):
+ self._py_file = py_file
+ # Note IPython enhances the linecache module to be able to
+ # inspect source code of functions defined on the interactive prompt.
+ source = inspect.getsource(py_func)
+ if isinstance(source, bytes):
+ self._bytes_source = source
+ else:
+ self._bytes_source = source.encode('utf-8')
+
+ def get_cache_path(self):
+ # We could also use jupyter_core.paths.jupyter_runtime_dir()
+ # In both cases this is a user-wide directory, so we need to
+ # be careful when disambiguating if we don't want too many
+ # conflicts (see below).
+ try:
+ from IPython.paths import get_ipython_cache_dir
+ except ImportError:
+ # older IPython version
+ from IPython.utils.path import get_ipython_cache_dir
+ return os.path.join(get_ipython_cache_dir(), 'numba_cache')
+
+ def get_source_stamp(self):
+ return hashlib.sha256(self._bytes_source).hexdigest()
+
+ def get_disambiguator(self):
+ # Heuristic: we don't want too many variants being saved, but
+ # we don't want similar named functions (e.g. "f") to compete
+ # for the cache, so we hash the first two lines of the function
+ # source (usually this will be the @jit decorator + the function
+ # signature).
+ firstlines = b''.join(self._bytes_source.splitlines(True)[:2])
+ return hashlib.sha256(firstlines).hexdigest()[:10]
+
+ @classmethod
+ def from_function(cls, py_func, py_file):
+ if not (
+ py_file.startswith("' can appear in the qualname (e.g. '') but
+ # are forbidden in Windows filenames
+ fixed_fullname = fullname.replace('<', '').replace('>', '')
+ fmt = '%s-%s.py%d%d%s'
+ return fmt % (fixed_fullname, self.locator.get_disambiguator(),
+ sys.version_info[0], sys.version_info[1], abiflags)
+
+ @property
+ def filename_base(self):
+ return self._filename_base
+
+ @property
+ def locator(self):
+ return self._locator
+
+ @abstractmethod
+ def reduce(self, data):
+ "Returns the serialized form the data"
+ pass
+
+ @abstractmethod
+ def rebuild(self, target_context, reduced_data):
+ "Returns the de-serialized form of the *reduced_data*"
+ pass
+
+ @abstractmethod
+ def check_cachable(self, data):
+ "Returns True if the given data is cachable; otherwise, returns False."
+ pass
+
+
+class CompileResultCacheImpl(CacheImpl):
+ """
+ Implements the logic to cache CompileResult objects.
+ """
+
+ def reduce(self, cres):
+ """
+ Returns a serialized CompileResult
+ """
+ return cres._reduce()
+
+ def rebuild(self, target_context, payload):
+ """
+ Returns the unserialized CompileResult
+ """
+ return compiler.CompileResult._rebuild(target_context, *payload)
+
+ def check_cachable(self, cres):
+ """
+ Check cachability of the given compile result.
+ """
+ cannot_cache = None
+ if any(not x.can_cache for x in cres.lifted):
+ cannot_cache = "as it uses lifted code"
+ elif cres.library.has_dynamic_globals:
+ cannot_cache = ("as it uses dynamic globals "
+ "(such as ctypes pointers and large global arrays)")
+ if cannot_cache:
+ msg = ('Cannot cache compiled function "%s" %s'
+ % (cres.fndesc.qualname.split('.')[-1], cannot_cache))
+ warnings.warn_explicit(msg, NumbaWarning,
+ self._locator._py_file, self._lineno)
+ return False
+ return True
+
+
+class CodeLibraryCacheImpl(CacheImpl):
+ """
+ Implements the logic to cache CodeLibrary objects.
+ """
+
+ _filename_prefix = None # must be overridden
+
+ def reduce(self, codelib):
+ """
+ Returns a serialized CodeLibrary
+ """
+ return codelib.serialize_using_object_code()
+
+ def rebuild(self, target_context, payload):
+ """
+ Returns the unserialized CodeLibrary
+ """
+ return target_context.codegen().unserialize_library(payload)
+
+ def check_cachable(self, codelib):
+ """
+ Check cachability of the given CodeLibrary.
+ """
+ return not codelib.has_dynamic_globals
+
+ def get_filename_base(self, fullname, abiflags):
+ parent = super(CodeLibraryCacheImpl, self)
+ res = parent.get_filename_base(fullname, abiflags)
+ return '-'.join([self._filename_prefix, res])
+
+
+class IndexDataCacheFile(object):
+ """
+ Implements the logic for the index file and data file used by a cache.
+ """
+ def __init__(self, cache_path, filename_base, source_stamp):
+ self._cache_path = cache_path
+ self._index_name = '%s.nbi' % (filename_base,)
+ self._index_path = os.path.join(self._cache_path, self._index_name)
+ self._data_name_pattern = '%s.{number:d}.nbc' % (filename_base,)
+ self._source_stamp = source_stamp
+ self._version = numba.__version__
+
+ def flush(self):
+ self._save_index({})
+
+ def save(self, key, data):
+ """
+ Save a new cache entry with *key* and *data*.
+ """
+ overloads = self._load_index()
+ try:
+ # If key already exists, we will overwrite the file
+ data_name = overloads[key]
+ except KeyError:
+ # Find an available name for the data file
+ existing = set(overloads.values())
+ for i in itertools.count(1):
+ data_name = self._data_name(i)
+ if data_name not in existing:
+ break
+ overloads[key] = data_name
+ self._save_index(overloads)
+ self._save_data(data_name, data)
+
+ def load(self, key):
+ """
+ Load a cache entry with *key*.
+ """
+ overloads = self._load_index()
+ data_name = overloads.get(key)
+ if data_name is None:
+ return
+ try:
+ return self._load_data(data_name)
+ except OSError:
+ # File could have been removed while the index still refers it.
+ return
+
+ def _load_index(self):
+ """
+ Load the cache index and return it as a dictionary (possibly
+ empty if cache is empty or obsolete).
+ """
+ try:
+ with open(self._index_path, "rb") as f:
+ version = pickle.load(f)
+ data = f.read()
+ except FileNotFoundError:
+ # Index doesn't exist yet?
+ return {}
+ if version != self._version:
+ # This is another version. Avoid trying to unpickling the
+ # rest of the stream, as that may fail.
+ return {}
+ stamp, overloads = pickle.loads(data)
+ _cache_log("[cache] index loaded from %r", self._index_path)
+ if stamp != self._source_stamp:
+ # Cache is not fresh. Stale data files will be eventually
+ # overwritten, since they are numbered in incrementing order.
+ return {}
+ else:
+ return overloads
+
+ def _save_index(self, overloads):
+ data = self._source_stamp, overloads
+ data = self._dump(data)
+ with self._open_for_write(self._index_path) as f:
+ pickle.dump(self._version, f, protocol=-1)
+ f.write(data)
+ _cache_log("[cache] index saved to %r", self._index_path)
+
+ def _load_data(self, name):
+ path = self._data_path(name)
+ with open(path, "rb") as f:
+ data = f.read()
+ tup = pickle.loads(data)
+ _cache_log("[cache] data loaded from %r", path)
+ return tup
+
+ def _save_data(self, name, data):
+ data = self._dump(data)
+ path = self._data_path(name)
+ with self._open_for_write(path) as f:
+ f.write(data)
+ _cache_log("[cache] data saved to %r", path)
+
+ def _data_name(self, number):
+ return self._data_name_pattern.format(number=number)
+
+ def _data_path(self, name):
+ return os.path.join(self._cache_path, name)
+
+ def _dump(self, obj):
+ return dumps(obj)
+
+ @contextlib.contextmanager
+ def _open_for_write(self, filepath):
+ """
+ Open *filepath* for writing in a race condition-free way (hopefully).
+ uuid4 is used to try and avoid name collisions on a shared filesystem.
+ """
+ uid = uuid.uuid4().hex[:16] # avoid long paths
+ tmpname = '%s.tmp.%s' % (filepath, uid)
+ try:
+ with open(tmpname, "wb") as f:
+ yield f
+ os.replace(tmpname, filepath)
+ except Exception:
+ # In case of error, remove dangling tmp file
+ try:
+ os.unlink(tmpname)
+ except OSError:
+ pass
+ raise
+
+
+class Cache(_Cache):
+ """
+ A per-function compilation cache. The cache saves data in separate
+ data files and maintains information in an index file.
+
+ There is one index file per function and Python version
+ ("function_name-.pyXY.nbi") which contains a mapping of
+ signatures and architectures to data files.
+ It is prefixed by a versioning key and a timestamp of the Python source
+ file containing the function.
+
+ There is one data file ("function_name-.pyXY..nbc")
+ per function, function signature, target architecture and Python version.
+
+ Separate index and data files per Python version avoid pickle
+ compatibility problems.
+
+ Note:
+ This contains the driver logic only. The core logic is provided
+ by a subclass of ``CacheImpl`` specified as *_impl_class* in the subclass.
+ """
+
+ # The following class variables must be overridden by subclass.
+ _impl_class = None
+
+ def __init__(self, py_func):
+ self._name = repr(py_func)
+ self._py_func = py_func
+ self._impl = self._impl_class(py_func)
+ self._cache_path = self._impl.locator.get_cache_path()
+ # This may be a bit strict but avoids us maintaining a magic number
+ source_stamp = self._impl.locator.get_source_stamp()
+ filename_base = self._impl.filename_base
+ self._cache_file = IndexDataCacheFile(cache_path=self._cache_path,
+ filename_base=filename_base,
+ source_stamp=source_stamp)
+ self.enable()
+
+ def __repr__(self):
+ return "<%s py_func=%r>" % (self.__class__.__name__, self._name)
+
+ @property
+ def cache_path(self):
+ return self._cache_path
+
+ def enable(self):
+ self._enabled = True
+
+ def disable(self):
+ self._enabled = False
+
+ def flush(self):
+ self._cache_file.flush()
+
+ def load_overload(self, sig, target_context):
+ """
+ Load and recreate the cached object for the given signature,
+ using the *target_context*.
+ """
+ # Refresh the context to ensure it is initialized
+ target_context.refresh()
+ with self._guard_against_spurious_io_errors():
+ return self._load_overload(sig, target_context)
+ # None returned if the `with` block swallows an exception
+
+ def _load_overload(self, sig, target_context):
+ if not self._enabled:
+ return
+ key = self._index_key(sig, target_context.codegen())
+ data = self._cache_file.load(key)
+ if data is not None:
+ data = self._impl.rebuild(target_context, data)
+ return data
+
+ def save_overload(self, sig, data):
+ """
+ Save the data for the given signature in the cache.
+ """
+ with self._guard_against_spurious_io_errors():
+ self._save_overload(sig, data)
+
+ def _save_overload(self, sig, data):
+ if not self._enabled:
+ return
+ if not self._impl.check_cachable(data):
+ return
+ self._impl.locator.ensure_cache_path()
+ key = self._index_key(sig, data.codegen)
+ data = self._impl.reduce(data)
+ self._cache_file.save(key, data)
+
+ @contextlib.contextmanager
+ def _guard_against_spurious_io_errors(self):
+ if os.name == 'nt':
+ # Guard against permission errors due to accessing the file
+ # from several processes (see #2028)
+ try:
+ yield
+ except OSError as e:
+ if e.errno != errno.EACCES:
+ raise
+ else:
+ # No such conditions under non-Windows OSes
+ yield
+
+ def _index_key(self, sig, codegen):
+ """
+ Compute index key for the given signature and codegen.
+ It includes a description of the OS, target architecture and hashes of
+ the bytecode for the function and, if the function has a __closure__,
+ a hash of the cell_contents.
+ """
+ codebytes = self._py_func.__code__.co_code
+ if self._py_func.__closure__ is not None:
+ cvars = tuple([x.cell_contents for x in self._py_func.__closure__])
+ # Note: cloudpickle serializes a function differently depending
+ # on how the process is launched; e.g. multiprocessing.Process
+ cvarbytes = dumps(cvars)
+ else:
+ cvarbytes = b''
+
+ hasher = lambda x: hashlib.sha256(x).hexdigest()
+ return (sig, codegen.magic_tuple(), (hasher(codebytes),
+ hasher(cvarbytes),))
+
+
+class FunctionCache(Cache):
+ """
+ Implements Cache that saves and loads CompileResult objects.
+ """
+ _impl_class = CompileResultCacheImpl
+
+
+# Remember used cache filename prefixes.
+_lib_cache_prefixes = set([''])
+
+
+def make_library_cache(prefix):
+ """
+ Create a Cache class for additional compilation features to cache their
+ result for reuse. The cache is saved in filename pattern like
+ in ``FunctionCache`` but with additional *prefix* as specified.
+ """
+ # avoid cache prefix reuse
+ assert prefix not in _lib_cache_prefixes
+ _lib_cache_prefixes.add(prefix)
+
+ class CustomCodeLibraryCacheImpl(CodeLibraryCacheImpl):
+ _filename_prefix = prefix
+
+ class LibraryCache(Cache):
+ """
+ Implements Cache that saves and loads CodeLibrary objects for additional
+ feature for the specified python function.
+ """
+ _impl_class = CustomCodeLibraryCacheImpl
+
+ return LibraryCache
+
diff --git a/venv/lib/python3.10/site-packages/numba/core/callconv.py b/venv/lib/python3.10/site-packages/numba/core/callconv.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bf15431467300180ab09d0bffc77262bb1da5a6
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/callconv.py
@@ -0,0 +1,961 @@
+"""
+Calling conventions for Numba-compiled functions.
+"""
+
+from collections import namedtuple
+from collections.abc import Iterable
+import itertools
+import hashlib
+
+from llvmlite import ir
+
+from numba.core import types, cgutils, errors
+from numba.core.base import PYOBJECT, GENERIC_POINTER
+
+
+TryStatus = namedtuple('TryStatus', ['in_try', 'excinfo'])
+
+
+Status = namedtuple("Status",
+ ("code",
+ # If the function returned ok (a value or None)
+ "is_ok",
+ # If the function returned None
+ "is_none",
+ # If the function errored out (== not is_ok)
+ "is_error",
+ # If the generator exited with StopIteration
+ "is_stop_iteration",
+ # If the function errored with an already set exception
+ "is_python_exc",
+ # If the function errored with a user exception
+ "is_user_exc",
+ # The pointer to the exception info structure (for user
+ # exceptions)
+ "excinfoptr",
+ ))
+
+int32_t = ir.IntType(32)
+int64_t = ir.IntType(64)
+errcode_t = int32_t
+
+
+def _const_int(code):
+ return ir.Constant(errcode_t, code)
+
+
+RETCODE_OK = _const_int(0)
+RETCODE_EXC = _const_int(-1)
+RETCODE_NONE = _const_int(-2)
+# StopIteration
+RETCODE_STOPIT = _const_int(-3)
+
+FIRST_USEREXC = 1
+
+RETCODE_USEREXC = _const_int(FIRST_USEREXC)
+
+
+class BaseCallConv(object):
+
+ def __init__(self, context):
+ self.context = context
+
+ def return_optional_value(self, builder, retty, valty, value):
+ if valty == types.none:
+ # Value is none
+ self.return_native_none(builder)
+
+ elif retty == valty:
+ # Value is an optional, need a runtime switch
+ optval = self.context.make_helper(builder, retty, value=value)
+
+ validbit = cgutils.as_bool_bit(builder, optval.valid)
+ with builder.if_then(validbit):
+ retval = self.context.get_return_value(builder, retty.type,
+ optval.data)
+ self.return_value(builder, retval)
+
+ self.return_native_none(builder)
+
+ elif not isinstance(valty, types.Optional):
+ # Value is not an optional, need a cast
+ if valty != retty.type:
+ value = self.context.cast(builder, value, fromty=valty,
+ toty=retty.type)
+ retval = self.context.get_return_value(builder, retty.type, value)
+ self.return_value(builder, retval)
+
+ else:
+ raise NotImplementedError("returning {0} for {1}".format(valty,
+ retty))
+
+ def return_native_none(self, builder):
+ self._return_errcode_raw(builder, RETCODE_NONE)
+
+ def return_exc(self, builder):
+ self._return_errcode_raw(builder, RETCODE_EXC)
+
+ def return_stop_iteration(self, builder):
+ self._return_errcode_raw(builder, RETCODE_STOPIT)
+
+ def get_return_type(self, ty):
+ """
+ Get the actual type of the return argument for Numba type *ty*.
+ """
+ restype = self.context.data_model_manager[ty].get_return_type()
+ return restype.as_pointer()
+
+ def init_call_helper(self, builder):
+ """
+ Initialize and return a call helper object for the given builder.
+ """
+ ch = self._make_call_helper(builder)
+ builder.__call_helper = ch
+ return ch
+
+ def _get_call_helper(self, builder):
+ return builder.__call_helper
+
+ def unpack_exception(self, builder, pyapi, status):
+ return pyapi.unserialize(status.excinfoptr)
+
+ def raise_error(self, builder, pyapi, status):
+ """
+ Given a non-ok *status*, raise the corresponding Python exception.
+ """
+ bbend = builder.function.append_basic_block()
+
+ with builder.if_then(status.is_user_exc):
+ # Unserialize user exception.
+ # Make sure another error may not interfere.
+ pyapi.err_clear()
+ exc = self.unpack_exception(builder, pyapi, status)
+ with cgutils.if_likely(builder,
+ cgutils.is_not_null(builder, exc)):
+ pyapi.raise_object(exc) # steals ref
+ builder.branch(bbend)
+
+ with builder.if_then(status.is_stop_iteration):
+ pyapi.err_set_none("PyExc_StopIteration")
+ builder.branch(bbend)
+
+ with builder.if_then(status.is_python_exc):
+ # Error already raised => nothing to do
+ builder.branch(bbend)
+
+ pyapi.err_set_string("PyExc_SystemError",
+ "unknown error when calling native function")
+ builder.branch(bbend)
+
+ builder.position_at_end(bbend)
+
+ def decode_arguments(self, builder, argtypes, func):
+ """
+ Get the decoded (unpacked) Python arguments with *argtypes*
+ from LLVM function *func*. A tuple of LLVM values is returned.
+ """
+ raw_args = self.get_arguments(func)
+ arginfo = self._get_arg_packer(argtypes)
+ return arginfo.from_arguments(builder, raw_args)
+
+ def _get_arg_packer(self, argtypes):
+ """
+ Get an argument packer for the given argument types.
+ """
+ return self.context.get_arg_packer(argtypes)
+
+
+class MinimalCallConv(BaseCallConv):
+ """
+ A minimal calling convention, suitable for e.g. GPU targets.
+ The implemented function signature is:
+
+ retcode_t (*, ... )
+
+ The return code will be one of the RETCODE_* constants or a
+ function-specific user exception id (>= RETCODE_USEREXC).
+
+ Caller is responsible for allocating a slot for the return value
+ (passed as a pointer in the first argument).
+ """
+
+ def _make_call_helper(self, builder):
+ return _MinimalCallHelper()
+
+ def return_value(self, builder, retval):
+ retptr = builder.function.args[0]
+ assert retval.type == retptr.type.pointee, \
+ (str(retval.type), str(retptr.type.pointee))
+ builder.store(retval, retptr)
+ self._return_errcode_raw(builder, RETCODE_OK)
+
+ def return_user_exc(self, builder, exc, exc_args=None, loc=None,
+ func_name=None):
+ if exc is not None and not issubclass(exc, BaseException):
+ raise TypeError("exc should be None or exception class, got %r"
+ % (exc,))
+ if exc_args is not None and not isinstance(exc_args, tuple):
+ raise TypeError("exc_args should be None or tuple, got %r"
+ % (exc_args,))
+
+ # Build excinfo struct
+ if loc is not None:
+ fname = loc._raw_function_name()
+ if fname is None:
+ # could be exec() or REPL, try func_name
+ fname = func_name
+
+ locinfo = (fname, loc.filename, loc.line)
+ if None in locinfo:
+ locinfo = None
+ else:
+ locinfo = None
+
+ call_helper = self._get_call_helper(builder)
+ exc_id = call_helper._add_exception(exc, exc_args, locinfo)
+ self._return_errcode_raw(builder, _const_int(exc_id))
+
+ def return_status_propagate(self, builder, status):
+ self._return_errcode_raw(builder, status.code)
+
+ def _return_errcode_raw(self, builder, code):
+ if isinstance(code, int):
+ code = _const_int(code)
+ builder.ret(code)
+
+ def _get_return_status(self, builder, code):
+ """
+ Given a return *code*, get a Status instance.
+ """
+ norm = builder.icmp_signed('==', code, RETCODE_OK)
+ none = builder.icmp_signed('==', code, RETCODE_NONE)
+ ok = builder.or_(norm, none)
+ err = builder.not_(ok)
+ exc = builder.icmp_signed('==', code, RETCODE_EXC)
+ is_stop_iteration = builder.icmp_signed('==', code, RETCODE_STOPIT)
+ is_user_exc = builder.icmp_signed('>=', code, RETCODE_USEREXC)
+
+ status = Status(code=code,
+ is_ok=ok,
+ is_error=err,
+ is_python_exc=exc,
+ is_none=none,
+ is_user_exc=is_user_exc,
+ is_stop_iteration=is_stop_iteration,
+ excinfoptr=None)
+ return status
+
+ def get_function_type(self, restype, argtypes):
+ """
+ Get the implemented Function type for *restype* and *argtypes*.
+ """
+ arginfo = self._get_arg_packer(argtypes)
+ argtypes = list(arginfo.argument_types)
+ resptr = self.get_return_type(restype)
+ fnty = ir.FunctionType(errcode_t, [resptr] + argtypes)
+ return fnty
+
+ def decorate_function(self, fn, args, fe_argtypes, noalias=False):
+ """
+ Set names and attributes of function arguments.
+ """
+ assert not noalias
+ arginfo = self._get_arg_packer(fe_argtypes)
+ arginfo.assign_names(self.get_arguments(fn),
+ ['arg.' + a for a in args])
+ fn.args[0].name = ".ret"
+
+ def get_arguments(self, func):
+ """
+ Get the Python-level arguments of LLVM *func*.
+ """
+ return func.args[1:]
+
+ def call_function(self, builder, callee, resty, argtys, args):
+ """
+ Call the Numba-compiled *callee*.
+ """
+ retty = callee.args[0].type.pointee
+ retvaltmp = cgutils.alloca_once(builder, retty)
+ # initialize return value
+ builder.store(cgutils.get_null_value(retty), retvaltmp)
+
+ arginfo = self._get_arg_packer(argtys)
+ args = arginfo.as_arguments(builder, args)
+ realargs = [retvaltmp] + list(args)
+ code = builder.call(callee, realargs)
+ status = self._get_return_status(builder, code)
+ retval = builder.load(retvaltmp)
+ out = self.context.get_returned_value(builder, resty, retval)
+ return status, out
+
+
+class _MinimalCallHelper(object):
+ """
+ A call helper object for the "minimal" calling convention.
+ User exceptions are represented as integer codes and stored in
+ a mapping for retrieval from the caller.
+ """
+
+ def __init__(self):
+ self.exceptions = {}
+
+ def _add_exception(self, exc, exc_args, locinfo):
+ """
+ Add a new user exception to this helper. Returns an integer that can be
+ used to refer to the added exception in future.
+
+ Parameters
+ ----------
+ exc :
+ exception type
+ exc_args : None or tuple
+ exception args
+ locinfo : tuple
+ location information
+ """
+ exc_id = len(self.exceptions) + FIRST_USEREXC
+ self.exceptions[exc_id] = exc, exc_args, locinfo
+ return exc_id
+
+ def get_exception(self, exc_id):
+ """
+ Get information about a user exception. Returns a tuple of
+ (exception type, exception args, location information).
+
+ Parameters
+ ----------
+ id : integer
+ The ID of the exception to look up
+ """
+ try:
+ return self.exceptions[exc_id]
+ except KeyError:
+ msg = "unknown error %d in native function" % exc_id
+ exc = SystemError
+ exc_args = (msg,)
+ locinfo = None
+ return exc, exc_args, locinfo
+
+
+# The structure type constructed by PythonAPI.serialize_uncached()
+# i.e a {i8* pickle_buf, i32 pickle_bufsz, i8* hash_buf, i8* fn, i32 alloc_flag}
+PICKLE_BUF_IDX = 0
+PICKLE_BUFSZ_IDX = 1
+HASH_BUF_IDX = 2
+UNWRAP_FUNC_IDX = 3
+ALLOC_FLAG_IDX = 4
+excinfo_t = ir.LiteralStructType(
+ [GENERIC_POINTER, int32_t, GENERIC_POINTER, GENERIC_POINTER, int32_t])
+excinfo_ptr_t = ir.PointerType(excinfo_t)
+
+
+class CPUCallConv(BaseCallConv):
+ """
+ The calling convention for CPU targets.
+ The implemented function signature is:
+
+ retcode_t (*, excinfo **, ... )
+
+ The return code will be one of the RETCODE_* constants.
+ If RETCODE_USEREXC, the exception info pointer will be filled with
+ a pointer to a constant struct describing the raised exception.
+
+ Caller is responsible for allocating slots for the return value
+ and the exception info pointer (passed as first and second arguments,
+ respectively).
+ """
+ _status_ids = itertools.count(1)
+
+ def _make_call_helper(self, builder):
+ return None
+
+ def return_value(self, builder, retval):
+ retptr = self._get_return_argument(builder.function)
+ assert retval.type == retptr.type.pointee, \
+ (str(retval.type), str(retptr.type.pointee))
+ builder.store(retval, retptr)
+ self._return_errcode_raw(builder, RETCODE_OK)
+
+ def build_excinfo_struct(self, exc, exc_args, loc, func_name):
+ # Build excinfo struct
+ if loc is not None:
+ fname = loc._raw_function_name()
+ if fname is None:
+ # could be exec() or REPL, try func_name
+ fname = func_name
+
+ locinfo = (fname, loc.filename, loc.line)
+ if None in locinfo:
+ locinfo = None
+ else:
+ locinfo = None
+
+ exc = (exc, exc_args, locinfo)
+ return exc
+
+ def set_static_user_exc(self, builder, exc, exc_args=None, loc=None,
+ func_name=None):
+ if exc is not None and not issubclass(exc, BaseException):
+ raise TypeError("exc should be None or exception class, got %r"
+ % (exc,))
+ if exc_args is not None and not isinstance(exc_args, tuple):
+ raise TypeError("exc_args should be None or tuple, got %r"
+ % (exc_args,))
+ # None is indicative of no args, set the exc_args to an empty tuple
+ # as PyObject_CallObject(exc, exc_args) requires the second argument to
+ # be a tuple (or nullptr, but doing this makes it consistent)
+ if exc_args is None:
+ exc_args = tuple()
+
+ # An exception in Numba is defined as the excinfo_t struct defined
+ # above. Some arguments in this struct are not used, depending on
+ # which kind of exception is being raised. A static exception uses
+ # only the first three members whilst a dynamic exception uses all
+ # members:
+ #
+ # static exc - last 2 args are NULL and 0
+ # vvv vvv vvv
+ # excinfo_t: {i8*, i32, i8*, i8*, i32}
+ # ^^^ ^^^ ^^^
+ # dynamic exc only - first 2 args are used for
+ # static info
+ #
+ # Comment below details how the struct is used in the case of a dynamic
+ # exception. For dynamic exceptions, see
+ # CPUCallConv::set_dynamic_user_exc
+ #
+ # {i8*, ___, ___, ___, ___}
+ # ^ serialized info about the exception (loc, kind, compile time
+ # args)
+ #
+ # {___, i32, ___, ___, ___}
+ # ^ len(serialized_exception)
+ #
+ # {___, ___, i8*, ___, ___}
+ # ^ Store a list of native values in a dynamic exception.
+ # Or a hash(serialized_exception) in a static exc.
+ #
+ # {___, ___, ___, i8*, ___}
+ # ^ "NULL" as this member is not used in a static exc
+ #
+ # {___, ___, ___, ___, i32}
+ # ^ Number of dynamic args in the exception. For
+ # static exceptions, this value is "0"
+
+ pyapi = self.context.get_python_api(builder)
+ exc = self.build_excinfo_struct(exc, exc_args, loc, func_name)
+ struct_gv = pyapi.serialize_object(exc)
+ excptr = self._get_excinfo_argument(builder.function)
+ store = builder.store(struct_gv, excptr)
+ md = builder.module.add_metadata([ir.IntType(1)(1)])
+ store.set_metadata("numba_exception_output", md)
+
+ def return_user_exc(self, builder, exc, exc_args=None, loc=None,
+ func_name=None):
+ try_info = getattr(builder, '_in_try_block', False)
+ self.set_static_user_exc(builder, exc, exc_args=exc_args,
+ loc=loc, func_name=func_name)
+ self.check_try_status(builder)
+ if try_info:
+ # This is a hack for old-style impl.
+ # We will branch directly to the exception handler.
+ builder.branch(try_info['target'])
+ else:
+ # Return from the current function
+ self._return_errcode_raw(builder, RETCODE_USEREXC)
+
+ def unpack_dynamic_exception(self, builder, pyapi, status):
+ excinfo_ptr = status.excinfoptr
+
+ # load the serialized exception buffer from the module and create
+ # a python bytes object
+ picklebuf = builder.extract_value(
+ builder.load(excinfo_ptr), PICKLE_BUF_IDX)
+ picklebuf_sz = builder.extract_value(
+ builder.load(excinfo_ptr), PICKLE_BUFSZ_IDX)
+ static_exc_bytes = pyapi.bytes_from_string_and_size(
+ picklebuf, builder.sext(picklebuf_sz, pyapi.py_ssize_t))
+
+ # Load dynamic args (i8*) and the unwrap function
+ dyn_args = builder.extract_value(
+ builder.load(excinfo_ptr), HASH_BUF_IDX)
+ func_ptr = builder.extract_value(
+ builder.load(excinfo_ptr), UNWRAP_FUNC_IDX)
+
+ # Convert the unwrap function to a function pointer and call it.
+ # Function returns a python tuple with dynamic arguments converted to
+ # CPython objects
+ fnty = ir.FunctionType(PYOBJECT, [GENERIC_POINTER])
+ fn = builder.bitcast(func_ptr, fnty.as_pointer())
+ py_tuple = builder.call(fn, [dyn_args])
+
+ # We check at this stage if creating the Python tuple was successful
+ # or not. Note the exception is raised by calling PyErr_SetString
+ # directly as the current function is the CPython wrapper.
+ failed = cgutils.is_null(builder, py_tuple)
+ with cgutils.if_unlikely(builder, failed):
+ msg = ('Error creating Python tuple from runtime exception '
+ 'arguments')
+ pyapi.err_set_string("PyExc_RuntimeError", msg)
+ # Return NULL to indicate an error was raised
+ fnty = builder.function.function_type
+ if not isinstance(fnty.return_type, ir.VoidType):
+ # in some ufuncs, the return type is void
+ builder.ret(cgutils.get_null_value(fnty.return_type))
+ else:
+ builder.ret_void()
+
+ # merge static and dynamic variables
+ excinfo = pyapi.build_dynamic_excinfo_struct(static_exc_bytes, py_tuple)
+
+ # At this point, one can free the entire excinfo_ptr struct
+ if self.context.enable_nrt:
+ # One can safely emit a free instruction as it is only executed
+ # if its in a dynamic exception branch
+ self.context.nrt.free(
+ builder, builder.bitcast(excinfo_ptr, pyapi.voidptr))
+ return excinfo
+
+ def unpack_exception(self, builder, pyapi, status):
+ # Emit code that checks the alloc flag (last excinfo member)
+ # if alloc_flag > 0:
+ # (dynamic) unpack the exception to retrieve runtime information
+ # and merge with static info
+ # else:
+ # (static) unserialize the exception using pythonapi.unserialize
+
+ excinfo_ptr = status.excinfoptr
+ alloc_flag = builder.extract_value(builder.load(excinfo_ptr),
+ ALLOC_FLAG_IDX)
+ gt = builder.icmp_signed('>', alloc_flag, int32_t(0))
+ with builder.if_else(gt) as (then, otherwise):
+ with then:
+ dyn_exc = self.unpack_dynamic_exception(builder, pyapi, status)
+ bb_then = builder.block
+ with otherwise:
+ static_exc = pyapi.unserialize(excinfo_ptr)
+ bb_else = builder.block
+ phi = builder.phi(static_exc.type)
+ phi.add_incoming(dyn_exc, bb_then)
+ phi.add_incoming(static_exc, bb_else)
+ return phi
+
+ def emit_unwrap_dynamic_exception_fn(self, module, st_type, nb_types):
+ # Create a function that converts a list of runtime arguments to a tuple
+ # of PyObjects. i.e.:
+ #
+ # @njit('void(float, int64)')
+ # def func(a, b):
+ # raise ValueError(a, 123, b)
+ #
+ # The last three arguments of the exception info structure will hold:
+ # {___, ___, i8*, i8*, i32}
+ # ^ A ptr to a {f32, i64} struct
+ # ^ function ptr that converts i8* -> {f32, i64}* ->
+ # python tuple
+ # ^ Number of dynamic arguments = 2
+ #
+
+ _hash = hashlib.sha1(str(st_type).encode()).hexdigest()
+ name = f'__excinfo_unwrap_args{_hash}'
+ if name in module.globals:
+ return module.globals.get(name)
+
+ fnty = ir.FunctionType(GENERIC_POINTER, [GENERIC_POINTER])
+ fn = ir.Function(module, fnty, name)
+
+ # prevent the function from being inlined
+ fn.attributes.add('nounwind')
+ fn.attributes.add('noinline')
+
+ bb_entry = fn.append_basic_block('')
+ builder = ir.IRBuilder(bb_entry)
+ pyapi = self.context.get_python_api(builder)
+
+ # i8* -> {native arg1 type, native arg2 type, ...}
+ st_type_ptr = st_type.as_pointer()
+ st_ptr = builder.bitcast(fn.args[0], st_type_ptr)
+ # compile time values are stored as None
+ nb_types = [typ for typ in nb_types if typ is not None]
+
+ # convert native values into CPython objects
+ objs = []
+ env_manager = self.context.get_env_manager(builder,
+ return_pyobject=True)
+ for i, typ in enumerate(nb_types):
+ val = builder.extract_value(builder.load(st_ptr), i)
+ obj = pyapi.from_native_value(typ, val, env_manager=env_manager)
+
+ # If object cannot be boxed, raise an exception
+ if obj == cgutils.get_null_value(obj.type):
+ # When not supported, abort compilation
+ msg = f'Cannot convert native {typ} to a Python object.'
+ raise errors.TypingError(msg)
+
+ objs.append(obj)
+
+ # at this point, a pointer to the list of runtime values can be freed
+ self.context.nrt.free(builder,
+ self._get_return_argument(builder.function))
+
+ # Create a tuple of CPython objects
+ tup = pyapi.tuple_pack(objs)
+ builder.ret(tup)
+
+ return fn
+
+ def emit_wrap_args_insts(self, builder, pyapi, struct_type, exc_args):
+ """
+ Create an anonymous struct containing the given LLVM *values*.
+ """
+ st_size = pyapi.py_ssize_t(self.context.get_abi_sizeof(struct_type))
+
+ st_ptr = builder.bitcast(
+ self.context.nrt.allocate(builder, st_size),
+ struct_type.as_pointer())
+
+ # skip compile-time values
+ exc_args = [arg for arg in exc_args if isinstance(arg, ir.Value)]
+
+ zero = int32_t(0)
+ for idx, arg in enumerate(exc_args):
+ builder.store(arg, builder.gep(st_ptr, [zero, int32_t(idx)]))
+
+ return st_ptr
+
+ def set_dynamic_user_exc(self, builder, exc, exc_args, nb_types, loc=None,
+ func_name=None):
+ """
+ Compute the required bits to emit an exception with dynamic (runtime)
+ values
+ """
+ if not issubclass(exc, BaseException):
+ raise TypeError("exc should be an exception class, got %r"
+ % (exc,))
+ if exc_args is not None and not isinstance(exc_args, tuple):
+ raise TypeError("exc_args should be None or tuple, got %r"
+ % (exc_args,))
+
+ # An exception in Numba is defined as the excinfo_t struct defined
+ # above. Some arguments in this struct are not used, depending on
+ # which kind of exception is being raised. A static exception uses
+ # only the first three members whilst a dynamic exception uses all
+ # members:
+ #
+ # static exc - last 2 args are NULL and 0
+ # vvv vvv vvv
+ # excinfo_t: {i8*, i32, i8*, i8*, i32}
+ # ^^^ ^^^ ^^^
+ # dynamic exc only - first 2 args are used for
+ # static info
+ #
+ # Comment below details how the struct is used in the case of a dynamic
+ # exception. For static exception, see CPUCallConv::set_static_user_exc
+ #
+ # {i8*, ___, ___, ___, ___}
+ # ^ serialized info about the exception (loc, kind, compile time
+ # args)
+ #
+ # {___, i32, ___, ___, ___}
+ # ^ len(serialized_exception)
+ #
+ # {___, ___, i8*, ___, ___}
+ # ^ Store a list of native values in a dynamic exception.
+ # Or a hash(serialized_exception) in a static exc.
+ #
+ # {___, ___, ___, i8*, ___}
+ # ^ Pointer to function that convert native values
+ # into PyObject*. NULL in the case of a static
+ # exception
+ #
+ # {___, ___, ___, ___, i32}
+ # ^ Number of dynamic args in the exception.
+ # Default is "0"
+ #
+ # The following code will:
+ # 1) Serialize compile time information and store them in the first
+ # two args {i8*, i32, ___, ___, ___} of excinfo_t
+ # 2) Emit the required code for converting native values to CPython
+ # objects. Those objects are stored in the last three args
+ # {___, ___, i8*, i8*, i32} of excinfo_t
+ # 3) Allocate a new excinfo_t struct
+ # 4) Fill excinfo_t struct and copy the pointer to the excinfo** arg
+
+ # serialize comp. time args
+ pyapi = self.context.get_python_api(builder)
+ dummy = self.context.get_dummy_value()
+ exc_args_static = tuple(
+ [dummy if isinstance(arg, ir.Value) else arg for arg in exc_args])
+ exc = self.build_excinfo_struct(exc, exc_args_static, loc, func_name)
+ excinfo_pp = self._get_excinfo_argument(builder.function)
+ struct_gv = builder.load(pyapi.serialize_object(exc))
+
+ # Create the struct for runtime args and emit a function to convert it
+ # into a Python tuple
+ struct_type = ir.LiteralStructType([arg.type for arg in exc_args if
+ isinstance(arg, ir.Value)])
+ st_ptr = self.emit_wrap_args_insts(builder, pyapi, struct_type,
+ exc_args)
+ unwrap_fn = self.emit_unwrap_dynamic_exception_fn(
+ builder.module, struct_type, nb_types)
+
+ # allocate the excinfo struct
+ exc_size = pyapi.py_ssize_t(self.context.get_abi_sizeof(excinfo_t))
+ excinfo_p = builder.bitcast(
+ self.context.nrt.allocate(builder, exc_size),
+ excinfo_ptr_t)
+
+ # fill the args
+ zero = int32_t(0)
+ exc_fields = (builder.extract_value(struct_gv, PICKLE_BUF_IDX),
+ builder.extract_value(struct_gv, PICKLE_BUFSZ_IDX),
+ builder.bitcast(st_ptr, GENERIC_POINTER),
+ builder.bitcast(unwrap_fn, GENERIC_POINTER),
+ int32_t(len(struct_type)))
+ for idx, arg in enumerate(exc_fields):
+ builder.store(arg, builder.gep(excinfo_p, [zero, int32_t(idx)]))
+ builder.store(excinfo_p, excinfo_pp)
+
+ def return_dynamic_user_exc(self, builder, exc, exc_args, nb_types,
+ loc=None, func_name=None):
+ """
+ Same as ::return_user_exc but for dynamic exceptions
+ """
+ self.set_dynamic_user_exc(builder, exc, exc_args, nb_types,
+ loc=loc, func_name=func_name)
+ self._return_errcode_raw(builder, RETCODE_USEREXC)
+
+ def _get_try_state(self, builder):
+ try:
+ return builder.__eh_try_state
+ except AttributeError:
+ ptr = cgutils.alloca_once(
+ builder, cgutils.intp_t, name='try_state', zfill=True,
+ )
+ builder.__eh_try_state = ptr
+ return ptr
+
+ def check_try_status(self, builder):
+ try_state_ptr = self._get_try_state(builder)
+ try_depth = builder.load(try_state_ptr)
+ # try_depth > 0
+ in_try = builder.icmp_unsigned('>', try_depth, try_depth.type(0))
+
+ excinfoptr = self._get_excinfo_argument(builder.function)
+ excinfo = builder.load(excinfoptr)
+
+ return TryStatus(in_try=in_try, excinfo=excinfo)
+
+ def set_try_status(self, builder):
+ try_state_ptr = self._get_try_state(builder)
+ # Increment try depth
+ old = builder.load(try_state_ptr)
+ new = builder.add(old, old.type(1))
+ builder.store(new, try_state_ptr)
+
+ def unset_try_status(self, builder):
+ try_state_ptr = self._get_try_state(builder)
+ # Decrement try depth
+ old = builder.load(try_state_ptr)
+ new = builder.sub(old, old.type(1))
+ builder.store(new, try_state_ptr)
+
+ # Needs to reset the exception state so that the exception handler
+ # will run normally.
+ excinfoptr = self._get_excinfo_argument(builder.function)
+ null = cgutils.get_null_value(excinfoptr.type.pointee)
+ builder.store(null, excinfoptr)
+
+ def return_status_propagate(self, builder, status):
+ trystatus = self.check_try_status(builder)
+ excptr = self._get_excinfo_argument(builder.function)
+ builder.store(status.excinfoptr, excptr)
+ with builder.if_then(builder.not_(trystatus.in_try)):
+ self._return_errcode_raw(builder, status.code)
+
+ def _return_errcode_raw(self, builder, code):
+ builder.ret(code)
+
+ def _get_return_status(self, builder, code, excinfoptr):
+ """
+ Given a return *code* and *excinfoptr*, get a Status instance.
+ """
+ norm = builder.icmp_signed('==', code, RETCODE_OK)
+ none = builder.icmp_signed('==', code, RETCODE_NONE)
+ exc = builder.icmp_signed('==', code, RETCODE_EXC)
+ is_stop_iteration = builder.icmp_signed('==', code, RETCODE_STOPIT)
+ ok = builder.or_(norm, none)
+ err = builder.not_(ok)
+ is_user_exc = builder.icmp_signed('>=', code, RETCODE_USEREXC)
+ excinfoptr = builder.select(is_user_exc, excinfoptr,
+ ir.Constant(excinfo_ptr_t, ir.Undefined))
+
+ status = Status(code=code,
+ is_ok=ok,
+ is_error=err,
+ is_python_exc=exc,
+ is_none=none,
+ is_user_exc=is_user_exc,
+ is_stop_iteration=is_stop_iteration,
+ excinfoptr=excinfoptr)
+ return status
+
+ def get_function_type(self, restype, argtypes):
+ """
+ Get the implemented Function type for *restype* and *argtypes*.
+ """
+ arginfo = self._get_arg_packer(argtypes)
+ argtypes = list(arginfo.argument_types)
+ resptr = self.get_return_type(restype)
+ fnty = ir.FunctionType(errcode_t,
+ [resptr, ir.PointerType(excinfo_ptr_t)]
+ + argtypes)
+ return fnty
+
+ def decorate_function(self, fn, args, fe_argtypes, noalias=False):
+ """
+ Set names of function arguments, and add useful attributes to them.
+ """
+ arginfo = self._get_arg_packer(fe_argtypes)
+ arginfo.assign_names(self.get_arguments(fn),
+ ['arg.' + a for a in args])
+ retarg = self._get_return_argument(fn)
+ retarg.name = "retptr"
+ retarg.add_attribute("nocapture")
+ retarg.add_attribute("noalias")
+ excarg = self._get_excinfo_argument(fn)
+ excarg.name = "excinfo"
+ excarg.add_attribute("nocapture")
+ excarg.add_attribute("noalias")
+
+ if noalias:
+ args = self.get_arguments(fn)
+ for a in args:
+ if isinstance(a.type, ir.PointerType):
+ a.add_attribute("nocapture")
+ a.add_attribute("noalias")
+
+ # Add metadata to mark functions that may need NRT
+ # thus disabling aggressive refct pruning in removerefctpass.py
+ def type_may_always_need_nrt(ty):
+ # Returns True if it's a non-Array type that is contains MemInfo
+ if not isinstance(ty, types.Array):
+ dmm = self.context.data_model_manager
+ if dmm[ty].contains_nrt_meminfo():
+ return True
+ return False
+
+ args_may_always_need_nrt = any(
+ map(type_may_always_need_nrt, fe_argtypes)
+ )
+
+ if args_may_always_need_nrt:
+ nmd = fn.module.add_named_metadata(
+ 'numba_args_may_always_need_nrt',
+ )
+ nmd.add(fn.module.add_metadata([fn]))
+
+ def get_arguments(self, func):
+ """
+ Get the Python-level arguments of LLVM *func*.
+ """
+ return func.args[2:]
+
+ def _get_return_argument(self, func):
+ return func.args[0]
+
+ def _get_excinfo_argument(self, func):
+ return func.args[1]
+
+ def call_function(self, builder, callee, resty, argtys, args,
+ attrs=None):
+ """
+ Call the Numba-compiled *callee*.
+ Parameters:
+ -----------
+ attrs: LLVM style string or iterable of individual attributes, default
+ is None which specifies no attributes. Examples:
+ LLVM style string: "noinline fast"
+ Equivalent iterable: ("noinline", "fast")
+ """
+ retty = self.get_return_type(resty).pointee
+ actual_retty = self._get_return_argument(callee.function_type).pointee
+ if retty != actual_retty:
+ m = f"Function type returns {actual_retty} but resty={retty}"
+ raise ValueError(m)
+
+ retvaltmp = cgutils.alloca_once(builder, retty)
+ # initialize return value to zeros
+ builder.store(cgutils.get_null_value(retty), retvaltmp)
+
+ excinfoptr = cgutils.alloca_once(builder, ir.PointerType(excinfo_t),
+ name="excinfo")
+
+ arginfo = self._get_arg_packer(argtys)
+ args = list(arginfo.as_arguments(builder, args))
+ realargs = [retvaltmp, excinfoptr] + args
+ # deal with attrs, it's fine to specify a load in a string like
+ # "noinline fast" as per LLVM or equally as an iterable of individual
+ # attributes.
+ if attrs is None:
+ _attrs = ()
+ elif isinstance(attrs, Iterable) and not isinstance(attrs, str):
+ _attrs = tuple(attrs)
+ else:
+ raise TypeError("attrs must be an iterable of strings or None")
+ code = builder.call(callee, realargs, attrs=_attrs)
+ status = self._get_return_status(builder, code,
+ builder.load(excinfoptr))
+ retval = builder.load(retvaltmp)
+ out = self.context.get_returned_value(builder, resty, retval)
+ return status, out
+
+
+class ErrorModel(object):
+
+ def __init__(self, call_conv):
+ self.call_conv = call_conv
+
+ def fp_zero_division(self, builder, exc_args=None, loc=None):
+ if self.raise_on_fp_zero_division:
+ self.call_conv.return_user_exc(builder, ZeroDivisionError, exc_args,
+ loc)
+ return True
+ else:
+ return False
+
+
+class PythonErrorModel(ErrorModel):
+ """
+ The Python error model. Any invalid FP input raises an exception.
+ """
+ raise_on_fp_zero_division = True
+
+
+class NumpyErrorModel(ErrorModel):
+ """
+ In the Numpy error model, floating-point errors don't raise an
+ exception. The FPU exception state is inspected by Numpy at the
+ end of a ufunc's execution and a warning is raised if appropriate.
+
+ Note there's no easy way to set the FPU exception state from LLVM.
+ Instructions known to set an FP exception can be optimized away:
+ https://llvm.org/bugs/show_bug.cgi?id=6050
+ http://lists.llvm.org/pipermail/llvm-dev/2014-September/076918.html
+ http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20140929/237997.html
+ """
+ raise_on_fp_zero_division = False
+
+
+error_models = {
+ 'python': PythonErrorModel,
+ 'numpy': NumpyErrorModel,
+}
+
+
+def create_error_model(model_name, context):
+ """
+ Create an error model instance for the given target context.
+ """
+ return error_models[model_name](context.call_conv)
diff --git a/venv/lib/python3.10/site-packages/numba/core/callwrapper.py b/venv/lib/python3.10/site-packages/numba/core/callwrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..5508aa38e516b92d89f1c97c01c2ec861a612cc0
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/callwrapper.py
@@ -0,0 +1,226 @@
+from llvmlite.ir import Constant, IRBuilder
+import llvmlite.ir
+
+from numba.core import types, config, cgutils
+
+
+class _ArgManager(object):
+ """
+ A utility class to handle argument unboxing and cleanup
+ """
+ def __init__(self, context, builder, api, env_manager, endblk, nargs):
+ self.context = context
+ self.builder = builder
+ self.api = api
+ self.env_manager = env_manager
+ self.arg_count = 0 # how many function arguments have been processed
+ self.cleanups = []
+ self.nextblk = endblk
+
+ def add_arg(self, obj, ty):
+ """
+ Unbox argument and emit code that handles any error during unboxing.
+ Args are cleaned up in reverse order of the parameter list, and
+ cleanup begins as soon as unboxing of any argument fails. E.g. failure
+ on arg2 will result in control flow going through:
+
+ arg2.err -> arg1.err -> arg0.err -> arg.end (returns)
+ """
+ # Unbox argument
+ native = self.api.to_native_value(ty, obj)
+
+ # If an error occurred, go to the cleanup block for
+ # the previous argument
+ with cgutils.if_unlikely(self.builder, native.is_error):
+ self.builder.branch(self.nextblk)
+
+ # Define the cleanup function for the argument
+ def cleanup_arg():
+ # Native value reflection
+ self.api.reflect_native_value(ty, native.value, self.env_manager)
+
+ # Native value cleanup
+ if native.cleanup is not None:
+ native.cleanup()
+
+ # NRT cleanup
+ # (happens after the native value cleanup as the latter
+ # may need the native value)
+ if self.context.enable_nrt:
+ self.context.nrt.decref(self.builder, ty, native.value)
+
+ self.cleanups.append(cleanup_arg)
+
+ # Write the on-error cleanup block for this argument
+ cleanupblk = self.builder.append_basic_block(
+ "arg%d.err" % self.arg_count)
+ with self.builder.goto_block(cleanupblk):
+ cleanup_arg()
+ # Go to next cleanup block
+ self.builder.branch(self.nextblk)
+
+ self.nextblk = cleanupblk
+ self.arg_count += 1
+ return native.value
+
+ def emit_cleanup(self):
+ """
+ Emit the cleanup code after returning from the wrapped function.
+ """
+ for dtor in self.cleanups:
+ dtor()
+
+
+class _GilManager(object):
+ """
+ A utility class to handle releasing the GIL and then re-acquiring it
+ again.
+ """
+
+ def __init__(self, builder, api, argman):
+ self.builder = builder
+ self.api = api
+ self.argman = argman
+ self.thread_state = api.save_thread()
+
+ def emit_cleanup(self):
+ self.api.restore_thread(self.thread_state)
+ self.argman.emit_cleanup()
+
+
+class PyCallWrapper(object):
+ def __init__(self, context, module, func, fndesc, env, call_helper,
+ release_gil):
+ self.context = context
+ self.module = module
+ self.func = func
+ self.fndesc = fndesc
+ self.env = env
+ self.release_gil = release_gil
+
+ def build(self):
+ wrapname = self.fndesc.llvm_cpython_wrapper_name
+
+ # This is the signature of PyCFunctionWithKeywords
+ # (see CPython's methodobject.h)
+ pyobj = self.context.get_argument_type(types.pyobject)
+ wrapty = llvmlite.ir.FunctionType(pyobj, [pyobj, pyobj, pyobj])
+ wrapper = llvmlite.ir.Function(self.module, wrapty, name=wrapname)
+
+ builder = IRBuilder(wrapper.append_basic_block('entry'))
+
+ # - `closure` will receive the `self` pointer stored in the
+ # PyCFunction object (see _dynfunc.c)
+ # - `args` and `kws` will receive the tuple and dict objects
+ # of positional and keyword arguments, respectively.
+ closure, args, kws = wrapper.args
+ closure.name = 'py_closure'
+ args.name = 'py_args'
+ kws.name = 'py_kws'
+
+ api = self.context.get_python_api(builder)
+ self.build_wrapper(api, builder, closure, args, kws)
+
+ return wrapper, api
+
+ def build_wrapper(self, api, builder, closure, args, kws):
+ nargs = len(self.fndesc.argtypes)
+
+ objs = [api.alloca_obj() for _ in range(nargs)]
+ parseok = api.unpack_tuple(args, self.fndesc.qualname,
+ nargs, nargs, *objs)
+
+ pred = builder.icmp_unsigned(
+ '==',
+ parseok,
+ Constant(parseok.type, None))
+ with cgutils.if_unlikely(builder, pred):
+ builder.ret(api.get_null_object())
+
+ # Block that returns after erroneous argument unboxing/cleanup
+ endblk = builder.append_basic_block("arg.end")
+ with builder.goto_block(endblk):
+ builder.ret(api.get_null_object())
+
+ # Get the Environment object
+ env_manager = self.get_env(api, builder)
+
+ cleanup_manager = _ArgManager(self.context, builder, api,
+ env_manager, endblk, nargs)
+
+ # Compute the arguments to the compiled Numba function.
+ innerargs = []
+ for obj, ty in zip(objs, self.fndesc.argtypes):
+ if isinstance(ty, types.Omitted):
+ # It's an omitted value => ignore dummy Python object
+ innerargs.append(None)
+ else:
+ val = cleanup_manager.add_arg(builder.load(obj), ty)
+ innerargs.append(val)
+
+ if self.release_gil:
+ cleanup_manager = _GilManager(builder, api, cleanup_manager)
+
+ # We elect to not inline the top level user function into the call
+ # wrapper, this incurs an overhead of a function call, however, it
+ # increases optimisation stability in that the optimised user function
+ # is what will actually be run and it is this function that all the
+ # inspection tools "see". Further, this makes optimisation "stable" in
+ # that calling the user function from e.g. C or from this wrapper will
+ # result in the same code executing, were inlining permitted this may
+ # not be the case as the inline could trigger additional optimisation
+ # as the function goes into the wrapper, this resulting in the executing
+ # instruction stream being different from that of the instruction stream
+ # present in the user function.
+ status, retval = self.context.call_conv.call_function(
+ builder, self.func, self.fndesc.restype, self.fndesc.argtypes,
+ innerargs, attrs=('noinline',))
+ # Do clean up
+ self.debug_print(builder, "# callwrapper: emit_cleanup")
+ cleanup_manager.emit_cleanup()
+ self.debug_print(builder, "# callwrapper: emit_cleanup end")
+
+ # Determine return status
+ with builder.if_then(status.is_ok, likely=True):
+ # Ok => return boxed Python value
+ with builder.if_then(status.is_none):
+ api.return_none()
+
+ retty = self._simplified_return_type()
+ obj = api.from_native_return(retty, retval, env_manager)
+ builder.ret(obj)
+
+ # Error out
+ self.context.call_conv.raise_error(builder, api, status)
+ builder.ret(api.get_null_object())
+
+ def get_env(self, api, builder):
+ """Get the Environment object which is declared as a global
+ in the module of the wrapped function.
+ """
+ envname = self.context.get_env_name(self.fndesc)
+ gvptr = self.context.declare_env_global(builder.module, envname)
+ envptr = builder.load(gvptr)
+
+ env_body = self.context.get_env_body(builder, envptr)
+
+ api.emit_environment_sentry(envptr, return_pyobject=True,
+ debug_msg=self.fndesc.env_name)
+ env_manager = api.get_env_manager(self.env, env_body, envptr)
+ return env_manager
+
+ def _simplified_return_type(self):
+ """
+ The NPM callconv has already converted simplified optional types.
+ We can simply use the value type from it.
+ """
+ restype = self.fndesc.restype
+ # Optional type
+ if isinstance(restype, types.Optional):
+ return restype.type
+ else:
+ return restype
+
+ def debug_print(self, builder, msg):
+ if config.DEBUG_JIT:
+ self.context.debug_print(builder, "DEBUGJIT: {0}".format(msg))
diff --git a/venv/lib/python3.10/site-packages/numba/core/ccallback.py b/venv/lib/python3.10/site-packages/numba/core/ccallback.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68d0efb5f4831233f56fecfc79af50cc2791064
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/ccallback.py
@@ -0,0 +1,135 @@
+"""
+Implementation of compiled C callbacks (@cfunc).
+"""
+
+
+import ctypes
+from functools import cached_property
+
+from numba.core import compiler, registry
+from numba.core.caching import NullCache, FunctionCache
+from numba.core.dispatcher import _FunctionCompiler
+from numba.core.typing import signature
+from numba.core.typing.ctypes_utils import to_ctypes
+from numba.core.compiler_lock import global_compiler_lock
+
+
+class _CFuncCompiler(_FunctionCompiler):
+
+ def _customize_flags(self, flags):
+ flags.no_cpython_wrapper = True
+ flags.no_cfunc_wrapper = False
+ # Disable compilation of the IR module, because we first want to
+ # add the cfunc wrapper.
+ flags.no_compile = True
+ # Object mode is not currently supported in C callbacks
+ # (no reliable way to get the environment)
+ flags.enable_pyobject = False
+ if flags.force_pyobject:
+ raise NotImplementedError("object mode not allowed in C callbacks")
+ return flags
+
+
+class CFunc(object):
+ """
+ A compiled C callback, as created by the @cfunc decorator.
+ """
+ _targetdescr = registry.cpu_target
+
+ def __init__(self, pyfunc, sig, locals, options,
+ pipeline_class=compiler.Compiler):
+ args, return_type = sig
+ if return_type is None:
+ raise TypeError("C callback needs an explicit return type")
+ self.__name__ = pyfunc.__name__
+ self.__qualname__ = getattr(pyfunc, '__qualname__', self.__name__)
+ self.__wrapped__ = pyfunc
+
+ self._pyfunc = pyfunc
+ self._sig = signature(return_type, *args)
+ self._compiler = _CFuncCompiler(pyfunc, self._targetdescr,
+ options, locals,
+ pipeline_class=pipeline_class)
+
+ self._wrapper_name = None
+ self._wrapper_address = None
+ self._cache = NullCache()
+ self._cache_hits = 0
+
+ def enable_caching(self):
+ self._cache = FunctionCache(self._pyfunc)
+
+ @global_compiler_lock
+ def compile(self):
+ # Try to load from cache
+ cres = self._cache.load_overload(self._sig,
+ self._targetdescr.target_context)
+ if cres is None:
+ cres = self._compile_uncached()
+ self._cache.save_overload(self._sig, cres)
+ else:
+ self._cache_hits += 1
+
+ self._library = cres.library
+ self._wrapper_name = cres.fndesc.llvm_cfunc_wrapper_name
+ self._wrapper_address = self._library.get_pointer_to_function(
+ self._wrapper_name)
+
+ def _compile_uncached(self):
+ sig = self._sig
+
+ # Compile native function as well as cfunc wrapper
+ return self._compiler.compile(sig.args, sig.return_type)
+
+ @property
+ def native_name(self):
+ """
+ The process-wide symbol the C callback is exposed as.
+ """
+ # Note from our point of view, the C callback is the wrapper around
+ # the native function.
+ return self._wrapper_name
+
+ @property
+ def address(self):
+ """
+ The address of the C callback.
+ """
+ return self._wrapper_address
+
+ @cached_property
+ def cffi(self):
+ """
+ A cffi function pointer representing the C callback.
+ """
+ import cffi
+ ffi = cffi.FFI()
+ # cffi compares types by name, so using precise types would risk
+ # spurious mismatches (such as "int32_t" vs. "int").
+ return ffi.cast("void *", self.address)
+
+ @cached_property
+ def ctypes(self):
+ """
+ A ctypes function object representing the C callback.
+ """
+ ctypes_args = [to_ctypes(ty) for ty in self._sig.args]
+ ctypes_restype = to_ctypes(self._sig.return_type)
+ functype = ctypes.CFUNCTYPE(ctypes_restype, *ctypes_args)
+ return functype(self.address)
+
+ def inspect_llvm(self):
+ """
+ Return the LLVM IR of the C callback definition.
+ """
+ return self._library.get_llvm_str()
+
+ @property
+ def cache_hits(self):
+ return self._cache_hits
+
+ def __repr__(self):
+ return "" % (self.__qualname__,)
+
+ def __call__(self, *args, **kwargs):
+ return self._pyfunc(*args, **kwargs)
diff --git a/venv/lib/python3.10/site-packages/numba/core/cgutils.py b/venv/lib/python3.10/site-packages/numba/core/cgutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..04bb3cb5c072b929612ea7856cf4bd12a80c668a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/cgutils.py
@@ -0,0 +1,1239 @@
+"""
+Generic helpers for LLVM code generation.
+"""
+
+
+import collections
+from contextlib import contextmanager, ExitStack
+import functools
+
+from llvmlite import ir
+
+from numba.core import utils, types, config, debuginfo
+import numba.core.datamodel
+
+
+bool_t = ir.IntType(1)
+int8_t = ir.IntType(8)
+int32_t = ir.IntType(32)
+intp_t = ir.IntType(utils.MACHINE_BITS)
+voidptr_t = int8_t.as_pointer()
+
+true_bit = bool_t(1)
+false_bit = bool_t(0)
+true_byte = int8_t(1)
+false_byte = int8_t(0)
+
+
+def as_bool_bit(builder, value):
+ return builder.icmp_unsigned('!=', value, value.type(0))
+
+
+def make_anonymous_struct(builder, values, struct_type=None):
+ """
+ Create an anonymous struct containing the given LLVM *values*.
+ """
+ if struct_type is None:
+ struct_type = ir.LiteralStructType([v.type for v in values])
+ struct_val = struct_type(ir.Undefined)
+ for i, v in enumerate(values):
+ struct_val = builder.insert_value(struct_val, v, i)
+ return struct_val
+
+
+def make_bytearray(buf):
+ """
+ Make a byte array constant from *buf*.
+ """
+ b = bytearray(buf)
+ n = len(b)
+ return ir.Constant(ir.ArrayType(ir.IntType(8), n), b)
+
+
+_struct_proxy_cache = {}
+
+
+def create_struct_proxy(fe_type, kind='value'):
+ """
+ Returns a specialized StructProxy subclass for the given fe_type.
+ """
+ cache_key = (fe_type, kind)
+ res = _struct_proxy_cache.get(cache_key)
+ if res is None:
+ base = {'value': ValueStructProxy,
+ 'data': DataStructProxy,
+ }[kind]
+ clsname = base.__name__ + '_' + str(fe_type)
+ bases = (base,)
+ clsmembers = dict(_fe_type=fe_type)
+ res = type(clsname, bases, clsmembers)
+
+ _struct_proxy_cache[cache_key] = res
+ return res
+
+
+def copy_struct(dst, src, repl={}):
+ """
+ Copy structure from *src* to *dst* with replacement from *repl*.
+ """
+ repl = repl.copy()
+ # copy data from src or use those in repl
+ for k in src._datamodel._fields:
+ v = repl.pop(k, getattr(src, k))
+ setattr(dst, k, v)
+ # use remaining key-values in repl
+ for k, v in repl.items():
+ setattr(dst, k, v)
+ return dst
+
+
+class _StructProxy(object):
+ """
+ Creates a `Structure` like interface that is constructed with information
+ from DataModel instance. FE type must have a data model that is a
+ subclass of StructModel.
+ """
+ # The following class members must be overridden by subclass
+ _fe_type = None
+
+ def __init__(self, context, builder, value=None, ref=None):
+ self._context = context
+ self._datamodel = self._context.data_model_manager[self._fe_type]
+ if not isinstance(self._datamodel, numba.core.datamodel.StructModel):
+ raise TypeError(
+ "Not a structure model: {0}".format(self._datamodel))
+ self._builder = builder
+
+ self._be_type = self._get_be_type(self._datamodel)
+ assert not is_pointer(self._be_type)
+
+ outer_ref, ref = self._make_refs(ref)
+ if ref.type.pointee != self._be_type:
+ raise AssertionError("bad ref type: expected %s, got %s"
+ % (self._be_type.as_pointer(), ref.type))
+
+ if value is not None:
+ if value.type != outer_ref.type.pointee:
+ raise AssertionError("bad value type: expected %s, got %s"
+ % (outer_ref.type.pointee, value.type))
+ self._builder.store(value, outer_ref)
+
+ self._value = ref
+ self._outer_ref = outer_ref
+
+ def _make_refs(self, ref):
+ """
+ Return an (outer ref, value ref) pair. By default, these are
+ the same pointers, but a derived class may override this.
+ """
+ if ref is None:
+ ref = alloca_once(self._builder, self._be_type, zfill=True)
+ return ref, ref
+
+ def _get_be_type(self, datamodel):
+ raise NotImplementedError
+
+ def _cast_member_to_value(self, index, val):
+ raise NotImplementedError
+
+ def _cast_member_from_value(self, index, val):
+ raise NotImplementedError
+
+ def _get_ptr_by_index(self, index):
+ return gep_inbounds(self._builder, self._value, 0, index)
+
+ def _get_ptr_by_name(self, attrname):
+ index = self._datamodel.get_field_position(attrname)
+ return self._get_ptr_by_index(index)
+
+ def __getattr__(self, field):
+ """
+ Load the LLVM value of the named *field*.
+ """
+ if not field.startswith('_'):
+ return self[self._datamodel.get_field_position(field)]
+ else:
+ raise AttributeError(field)
+
+ def __setattr__(self, field, value):
+ """
+ Store the LLVM *value* into the named *field*.
+ """
+ if field.startswith('_'):
+ return super(_StructProxy, self).__setattr__(field, value)
+ self[self._datamodel.get_field_position(field)] = value
+
+ def __getitem__(self, index):
+ """
+ Load the LLVM value of the field at *index*.
+ """
+ member_val = self._builder.load(self._get_ptr_by_index(index))
+ return self._cast_member_to_value(index, member_val)
+
+ def __setitem__(self, index, value):
+ """
+ Store the LLVM *value* into the field at *index*.
+ """
+ ptr = self._get_ptr_by_index(index)
+ value = self._cast_member_from_value(index, value)
+ if value.type != ptr.type.pointee:
+ if (is_pointer(value.type) and is_pointer(ptr.type.pointee)
+ and value.type.pointee == ptr.type.pointee.pointee):
+ # Differ by address-space only
+ # Auto coerce it
+ value = self._context.addrspacecast(self._builder,
+ value,
+ ptr.type.pointee.addrspace)
+ else:
+ raise TypeError("Invalid store of {value.type} to "
+ "{ptr.type.pointee} in "
+ "{self._datamodel} "
+ "(trying to write member #{index})"
+ .format(value=value, ptr=ptr, self=self,
+ index=index))
+ self._builder.store(value, ptr)
+
+ def __len__(self):
+ """
+ Return the number of fields.
+ """
+ return self._datamodel.field_count
+
+ def _getpointer(self):
+ """
+ Return the LLVM pointer to the underlying structure.
+ """
+ return self._outer_ref
+
+ def _getvalue(self):
+ """
+ Load and return the value of the underlying LLVM structure.
+ """
+ return self._builder.load(self._outer_ref)
+
+ def _setvalue(self, value):
+ """
+ Store the value in this structure.
+ """
+ assert not is_pointer(value.type)
+ assert value.type == self._be_type, (value.type, self._be_type)
+ self._builder.store(value, self._value)
+
+
+class ValueStructProxy(_StructProxy):
+ """
+ Create a StructProxy suitable for accessing regular values
+ (e.g. LLVM values or alloca slots).
+ """
+ def _get_be_type(self, datamodel):
+ return datamodel.get_value_type()
+
+ def _cast_member_to_value(self, index, val):
+ return val
+
+ def _cast_member_from_value(self, index, val):
+ return val
+
+
+class DataStructProxy(_StructProxy):
+ """
+ Create a StructProxy suitable for accessing data persisted in memory.
+ """
+ def _get_be_type(self, datamodel):
+ return datamodel.get_data_type()
+
+ def _cast_member_to_value(self, index, val):
+ model = self._datamodel.get_model(index)
+ return model.from_data(self._builder, val)
+
+ def _cast_member_from_value(self, index, val):
+ model = self._datamodel.get_model(index)
+ return model.as_data(self._builder, val)
+
+
+class Structure(object):
+ """
+ A high-level object wrapping a alloca'ed LLVM structure, including
+ named fields and attribute access.
+ """
+
+ # XXX Should this warrant several separate constructors?
+ def __init__(self, context, builder, value=None, ref=None, cast_ref=False):
+ self._type = context.get_struct_type(self)
+ self._context = context
+ self._builder = builder
+ if ref is None:
+ self._value = alloca_once(builder, self._type, zfill=True)
+ if value is not None:
+ assert not is_pointer(value.type)
+ assert value.type == self._type, (value.type, self._type)
+ builder.store(value, self._value)
+ else:
+ assert value is None
+ assert is_pointer(ref.type)
+ if self._type != ref.type.pointee:
+ if cast_ref:
+ ref = builder.bitcast(ref, self._type.as_pointer())
+ else:
+ raise TypeError(
+ "mismatching pointer type: got %s, expected %s"
+ % (ref.type.pointee, self._type))
+ self._value = ref
+
+ self._namemap = {}
+ self._fdmap = []
+ self._typemap = []
+ base = int32_t(0)
+ for i, (k, tp) in enumerate(self._fields):
+ self._namemap[k] = i
+ self._fdmap.append((base, int32_t(i)))
+ self._typemap.append(tp)
+
+ def _get_ptr_by_index(self, index):
+ ptr = self._builder.gep(self._value, self._fdmap[index], inbounds=True)
+ return ptr
+
+ def _get_ptr_by_name(self, attrname):
+ return self._get_ptr_by_index(self._namemap[attrname])
+
+ def __getattr__(self, field):
+ """
+ Load the LLVM value of the named *field*.
+ """
+ if not field.startswith('_'):
+ return self[self._namemap[field]]
+ else:
+ raise AttributeError(field)
+
+ def __setattr__(self, field, value):
+ """
+ Store the LLVM *value* into the named *field*.
+ """
+ if field.startswith('_'):
+ return super(Structure, self).__setattr__(field, value)
+ self[self._namemap[field]] = value
+
+ def __getitem__(self, index):
+ """
+ Load the LLVM value of the field at *index*.
+ """
+
+ return self._builder.load(self._get_ptr_by_index(index))
+
+ def __setitem__(self, index, value):
+ """
+ Store the LLVM *value* into the field at *index*.
+ """
+ ptr = self._get_ptr_by_index(index)
+ if ptr.type.pointee != value.type:
+ fmt = "Type mismatch: __setitem__(%d, ...) expected %r but got %r"
+ raise AssertionError(fmt % (index,
+ str(ptr.type.pointee),
+ str(value.type)))
+ self._builder.store(value, ptr)
+
+ def __len__(self):
+ """
+ Return the number of fields.
+ """
+ return len(self._namemap)
+
+ def _getpointer(self):
+ """
+ Return the LLVM pointer to the underlying structure.
+ """
+ return self._value
+
+ def _getvalue(self):
+ """
+ Load and return the value of the underlying LLVM structure.
+ """
+ return self._builder.load(self._value)
+
+ def _setvalue(self, value):
+ """Store the value in this structure"""
+ assert not is_pointer(value.type)
+ assert value.type == self._type, (value.type, self._type)
+ self._builder.store(value, self._value)
+
+ # __iter__ is derived by Python from __len__ and __getitem__
+
+
+def alloca_once(builder, ty, size=None, name='', zfill=False):
+ """Allocate stack memory at the entry block of the current function
+ pointed by ``builder`` with llvm type ``ty``. The optional ``size`` arg
+ set the number of element to allocate. The default is 1. The optional
+ ``name`` arg set the symbol name inside the llvm IR for debugging.
+ If ``zfill`` is set, fill the memory with zeros at the current
+ use-site location. Note that the memory is always zero-filled after the
+ ``alloca`` at init-site (the entry block).
+ """
+ if isinstance(size, int):
+ size = ir.Constant(intp_t, size)
+ # suspend debug metadata emission else it links up python source lines with
+ # alloca in the entry block as well as their actual location and it makes
+ # the debug info "jump about".
+ with debuginfo.suspend_emission(builder):
+ with builder.goto_entry_block():
+ ptr = builder.alloca(ty, size=size, name=name)
+ # Always zero-fill at init-site. This is safe.
+ builder.store(ty(None), ptr)
+ # Also zero-fill at the use-site
+ if zfill:
+ builder.store(ptr.type.pointee(None), ptr)
+ return ptr
+
+
+def sizeof(builder, ptr_type):
+ """Compute sizeof using GEP
+ """
+ null = ptr_type(None)
+ offset = null.gep([int32_t(1)])
+ return builder.ptrtoint(offset, intp_t)
+
+
+def alloca_once_value(builder, value, name='', zfill=False):
+ """
+ Like alloca_once(), but passing a *value* instead of a type. The
+ type is inferred and the allocated slot is also initialized with the
+ given value.
+ """
+ storage = alloca_once(builder, value.type, zfill=zfill)
+ builder.store(value, storage)
+ return storage
+
+
+def insert_pure_function(module, fnty, name):
+ """
+ Insert a pure function (in the functional programming sense) in the
+ given module.
+ """
+ fn = get_or_insert_function(module, fnty, name)
+ fn.attributes.add("readonly")
+ fn.attributes.add("nounwind")
+ return fn
+
+
+def get_or_insert_function(module, fnty, name):
+ """
+ Get the function named *name* with type *fnty* from *module*, or insert it
+ if it doesn't exist.
+ """
+ fn = module.globals.get(name, None)
+ if fn is None:
+ fn = ir.Function(module, fnty, name)
+ return fn
+
+
+def get_or_insert_named_metadata(module, name):
+ try:
+ return module.get_named_metadata(name)
+ except KeyError:
+ return module.add_named_metadata(name)
+
+
+def add_global_variable(module, ty, name, addrspace=0):
+ unique_name = module.get_unique_name(name)
+ return ir.GlobalVariable(module, ty, unique_name, addrspace)
+
+
+def terminate(builder, bbend):
+ bb = builder.basic_block
+ if bb.terminator is None:
+ builder.branch(bbend)
+
+
+def get_null_value(ltype):
+ return ltype(None)
+
+
+def is_null(builder, val):
+ null = get_null_value(val.type)
+ return builder.icmp_unsigned('==', null, val)
+
+
+def is_not_null(builder, val):
+ null = get_null_value(val.type)
+ return builder.icmp_unsigned('!=', null, val)
+
+
+def if_unlikely(builder, pred):
+ return builder.if_then(pred, likely=False)
+
+
+def if_likely(builder, pred):
+ return builder.if_then(pred, likely=True)
+
+
+def ifnot(builder, pred):
+ return builder.if_then(builder.not_(pred))
+
+
+def increment_index(builder, val):
+ """
+ Increment an index *val*.
+ """
+ one = val.type(1)
+ # We pass the "nsw" flag in the hope that LLVM understands the index
+ # never changes sign. Unfortunately this doesn't always work
+ # (e.g. ndindex()).
+ return builder.add(val, one, flags=['nsw'])
+
+
+Loop = collections.namedtuple('Loop', ('index', 'do_break'))
+
+
+@contextmanager
+def for_range(builder, count, start=None, intp=None):
+ """
+ Generate LLVM IR for a for-loop in [start, count).
+ *start* is equal to 0 by default.
+
+ Yields a Loop namedtuple with the following members:
+ - `index` is the loop index's value
+ - `do_break` is a no-argument callable to break out of the loop
+ """
+ if intp is None:
+ intp = count.type
+ if start is None:
+ start = intp(0)
+ stop = count
+
+ bbcond = builder.append_basic_block("for.cond")
+ bbbody = builder.append_basic_block("for.body")
+ bbend = builder.append_basic_block("for.end")
+
+ def do_break():
+ builder.branch(bbend)
+
+ bbstart = builder.basic_block
+ builder.branch(bbcond)
+
+ with builder.goto_block(bbcond):
+ index = builder.phi(intp, name="loop.index")
+ pred = builder.icmp_signed('<', index, stop)
+ builder.cbranch(pred, bbbody, bbend)
+
+ with builder.goto_block(bbbody):
+ yield Loop(index, do_break)
+ # Update bbbody as a new basic block may have been activated
+ bbbody = builder.basic_block
+ incr = increment_index(builder, index)
+ terminate(builder, bbcond)
+
+ index.add_incoming(start, bbstart)
+ index.add_incoming(incr, bbbody)
+
+ builder.position_at_end(bbend)
+
+
+@contextmanager
+def for_range_slice(builder, start, stop, step, intp=None, inc=True):
+ """
+ Generate LLVM IR for a for-loop based on a slice. Yields a
+ (index, count) tuple where `index` is the slice index's value
+ inside the loop, and `count` the iteration count.
+
+ Parameters
+ -------------
+ builder : object
+ IRBuilder object
+ start : int
+ The beginning value of the slice
+ stop : int
+ The end value of the slice
+ step : int
+ The step value of the slice
+ intp :
+ The data type
+ inc : boolean, optional
+ Signals whether the step is positive (True) or negative (False).
+
+ Returns
+ -----------
+ None
+ """
+ if intp is None:
+ intp = start.type
+
+ bbcond = builder.append_basic_block("for.cond")
+ bbbody = builder.append_basic_block("for.body")
+ bbend = builder.append_basic_block("for.end")
+ bbstart = builder.basic_block
+ builder.branch(bbcond)
+
+ with builder.goto_block(bbcond):
+ index = builder.phi(intp, name="loop.index")
+ count = builder.phi(intp, name="loop.count")
+ if (inc):
+ pred = builder.icmp_signed('<', index, stop)
+ else:
+ pred = builder.icmp_signed('>', index, stop)
+ builder.cbranch(pred, bbbody, bbend)
+
+ with builder.goto_block(bbbody):
+ yield index, count
+ bbbody = builder.basic_block
+ incr = builder.add(index, step)
+ next_count = increment_index(builder, count)
+ terminate(builder, bbcond)
+
+ index.add_incoming(start, bbstart)
+ index.add_incoming(incr, bbbody)
+ count.add_incoming(ir.Constant(intp, 0), bbstart)
+ count.add_incoming(next_count, bbbody)
+ builder.position_at_end(bbend)
+
+
+@contextmanager
+def for_range_slice_generic(builder, start, stop, step):
+ """
+ A helper wrapper for for_range_slice(). This is a context manager which
+ yields two for_range_slice()-alike context managers, the first for
+ the positive step case, the second for the negative step case.
+
+ Use:
+ with for_range_slice_generic(...) as (pos_range, neg_range):
+ with pos_range as (idx, count):
+ ...
+ with neg_range as (idx, count):
+ ...
+ """
+ intp = start.type
+ is_pos_step = builder.icmp_signed('>=', step, ir.Constant(intp, 0))
+
+ pos_for_range = for_range_slice(builder, start, stop, step, intp, inc=True)
+ neg_for_range = for_range_slice(builder, start, stop, step, intp, inc=False)
+
+ @contextmanager
+ def cm_cond(cond, inner_cm):
+ with cond:
+ with inner_cm as value:
+ yield value
+
+ with builder.if_else(is_pos_step, likely=True) as (then, otherwise):
+ yield cm_cond(then, pos_for_range), cm_cond(otherwise, neg_for_range)
+
+
+@contextmanager
+def loop_nest(builder, shape, intp, order='C'):
+ """
+ Generate a loop nest walking a N-dimensional array.
+ Yields a tuple of N indices for use in the inner loop body,
+ iterating over the *shape* space.
+
+ If *order* is 'C' (the default), indices are incremented inside-out
+ (i.e. (0,0), (0,1), (0,2), (1,0) etc.).
+ If *order* is 'F', they are incremented outside-in
+ (i.e. (0,0), (1,0), (2,0), (0,1) etc.).
+ This has performance implications when walking an array as it impacts
+ the spatial locality of memory accesses.
+ """
+ assert order in 'CF'
+ if not shape:
+ # 0-d array
+ yield ()
+ else:
+ if order == 'F':
+ _swap = lambda x: x[::-1]
+ else:
+ _swap = lambda x: x
+ with _loop_nest(builder, _swap(shape), intp) as indices:
+ assert len(indices) == len(shape)
+ yield _swap(indices)
+
+
+@contextmanager
+def _loop_nest(builder, shape, intp):
+ with for_range(builder, shape[0], intp=intp) as loop:
+ if len(shape) > 1:
+ with _loop_nest(builder, shape[1:], intp) as indices:
+ yield (loop.index,) + indices
+ else:
+ yield (loop.index,)
+
+
+def pack_array(builder, values, ty=None):
+ """
+ Pack a sequence of values in a LLVM array. *ty* should be given
+ if the array may be empty, in which case the type can't be inferred
+ from the values.
+ """
+ n = len(values)
+ if ty is None:
+ ty = values[0].type
+ ary = ir.ArrayType(ty, n)(ir.Undefined)
+ for i, v in enumerate(values):
+ ary = builder.insert_value(ary, v, i)
+ return ary
+
+
+def pack_struct(builder, values):
+ """
+ Pack a sequence of values into a LLVM struct.
+ """
+ structty = ir.LiteralStructType([v.type for v in values])
+ st = structty(ir.Undefined)
+ for i, v in enumerate(values):
+ st = builder.insert_value(st, v, i)
+ return st
+
+
+def unpack_tuple(builder, tup, count=None):
+ """
+ Unpack an array or structure of values, return a Python tuple.
+ """
+ if count is None:
+ # Assuming *tup* is an aggregate
+ count = len(tup.type.elements)
+ vals = [builder.extract_value(tup, i)
+ for i in range(count)]
+ return vals
+
+
+def get_item_pointer(context, builder, aryty, ary, inds, wraparound=False,
+ boundscheck=False):
+ # Set boundscheck=True for any pointer access that should be
+ # boundschecked. do_boundscheck() will handle enabling or disabling the
+ # actual boundschecking based on the user config.
+ shapes = unpack_tuple(builder, ary.shape, count=aryty.ndim)
+ strides = unpack_tuple(builder, ary.strides, count=aryty.ndim)
+ return get_item_pointer2(context, builder, data=ary.data, shape=shapes,
+ strides=strides, layout=aryty.layout, inds=inds,
+ wraparound=wraparound, boundscheck=boundscheck)
+
+
+def do_boundscheck(context, builder, ind, dimlen, axis=None):
+ def _dbg():
+ # Remove this when we figure out how to include this information
+ # in the error message.
+ if axis is not None:
+ if isinstance(axis, int):
+ printf(builder, "debug: IndexError: index %d is out of bounds "
+ "for axis {} with size %d\n".format(axis), ind, dimlen)
+ else:
+ printf(builder, "debug: IndexError: index %d is out of bounds "
+ "for axis %d with size %d\n", ind, axis,
+ dimlen)
+ else:
+ printf(builder,
+ "debug: IndexError: index %d is out of bounds for size %d\n",
+ ind, dimlen)
+
+ msg = "index is out of bounds"
+ out_of_bounds_upper = builder.icmp_signed('>=', ind, dimlen)
+ with if_unlikely(builder, out_of_bounds_upper):
+ if config.FULL_TRACEBACKS:
+ _dbg()
+ context.call_conv.return_user_exc(builder, IndexError, (msg,))
+ out_of_bounds_lower = builder.icmp_signed('<', ind, ind.type(0))
+ with if_unlikely(builder, out_of_bounds_lower):
+ if config.FULL_TRACEBACKS:
+ _dbg()
+ context.call_conv.return_user_exc(builder, IndexError, (msg,))
+
+
+def get_item_pointer2(context, builder, data, shape, strides, layout, inds,
+ wraparound=False, boundscheck=False):
+ # Set boundscheck=True for any pointer access that should be
+ # boundschecked. do_boundscheck() will handle enabling or disabling the
+ # actual boundschecking based on the user config.
+ if wraparound:
+ # Wraparound
+ indices = []
+ for ind, dimlen in zip(inds, shape):
+ negative = builder.icmp_signed('<', ind, ind.type(0))
+ wrapped = builder.add(dimlen, ind)
+ selected = builder.select(negative, wrapped, ind)
+ indices.append(selected)
+ else:
+ indices = inds
+ if boundscheck:
+ for axis, (ind, dimlen) in enumerate(zip(indices, shape)):
+ do_boundscheck(context, builder, ind, dimlen, axis)
+
+ if not indices:
+ # Indexing with empty tuple
+ return builder.gep(data, [int32_t(0)])
+ intp = indices[0].type
+ # Indexing code
+ if layout in 'CF':
+ steps = []
+ # Compute steps for each dimension
+ if layout == 'C':
+ # C contiguous
+ for i in range(len(shape)):
+ last = intp(1)
+ for j in shape[i + 1:]:
+ last = builder.mul(last, j)
+ steps.append(last)
+ elif layout == 'F':
+ # F contiguous
+ for i in range(len(shape)):
+ last = intp(1)
+ for j in shape[:i]:
+ last = builder.mul(last, j)
+ steps.append(last)
+ else:
+ raise Exception("unreachable")
+
+ # Compute index
+ loc = intp(0)
+ for i, s in zip(indices, steps):
+ tmp = builder.mul(i, s)
+ loc = builder.add(loc, tmp)
+ ptr = builder.gep(data, [loc])
+ return ptr
+ else:
+ # Any layout
+ dimoffs = [builder.mul(s, i) for s, i in zip(strides, indices)]
+ offset = functools.reduce(builder.add, dimoffs)
+ return pointer_add(builder, data, offset)
+
+
+def _scalar_pred_against_zero(builder, value, fpred, icond):
+ nullval = value.type(0)
+ if isinstance(value.type, (ir.FloatType, ir.DoubleType)):
+ isnull = fpred(value, nullval)
+ elif isinstance(value.type, ir.IntType):
+ isnull = builder.icmp_signed(icond, value, nullval)
+ else:
+ raise TypeError("unexpected value type %s" % (value.type,))
+ return isnull
+
+
+def is_scalar_zero(builder, value):
+ """
+ Return a predicate representing whether *value* is equal to zero.
+ """
+ return _scalar_pred_against_zero(
+ builder, value, functools.partial(builder.fcmp_ordered, '=='), '==')
+
+
+def is_not_scalar_zero(builder, value):
+ """
+ Return a predicate representing whether a *value* is not equal to zero.
+ (not exactly "not is_scalar_zero" because of nans)
+ """
+ return _scalar_pred_against_zero(
+ builder, value, functools.partial(builder.fcmp_unordered, '!='), '!=')
+
+
+def is_scalar_zero_or_nan(builder, value):
+ """
+ Return a predicate representing whether *value* is equal to either zero
+ or NaN.
+ """
+ return _scalar_pred_against_zero(
+ builder, value, functools.partial(builder.fcmp_unordered, '=='), '==')
+
+
+is_true = is_not_scalar_zero
+is_false = is_scalar_zero
+
+
+def is_scalar_neg(builder, value):
+ """
+ Is *value* negative? Assumes *value* is signed.
+ """
+ return _scalar_pred_against_zero(
+ builder, value, functools.partial(builder.fcmp_ordered, '<'), '<')
+
+
+@contextmanager
+def early_exit_if(builder, stack: ExitStack, cond):
+ """
+ The Python code::
+
+ with contextlib.ExitStack() as stack:
+ with early_exit_if(builder, stack, cond):
+ cleanup()
+ body()
+
+ emits the code::
+
+ if (cond) {
+
+ }
+ else {
+
+ }
+
+ This can be useful for generating code with lots of early exits, without
+ having to increase the indentation each time.
+ """
+ then, otherwise = stack.enter_context(builder.if_else(cond, likely=False))
+ with then:
+ yield
+ stack.enter_context(otherwise)
+
+
+def early_exit_if_null(builder, stack, obj):
+ """
+ A convenience wrapper for :func:`early_exit_if`, for the common case where
+ the CPython API indicates an error by returning ``NULL``.
+ """
+ return early_exit_if(builder, stack, is_null(builder, obj))
+
+
+def guard_null(context, builder, value, exc_tuple):
+ """
+ Guard against *value* being null or zero.
+ *exc_tuple* should be a (exception type, arguments...) tuple.
+ """
+ with builder.if_then(is_scalar_zero(builder, value), likely=False):
+ exc = exc_tuple[0]
+ exc_args = exc_tuple[1:] or None
+ context.call_conv.return_user_exc(builder, exc, exc_args)
+
+
+def guard_memory_error(context, builder, pointer, msg=None):
+ """
+ Guard against *pointer* being NULL (and raise a MemoryError).
+ """
+ assert isinstance(pointer.type, ir.PointerType), pointer.type
+ exc_args = (msg,) if msg else ()
+ with builder.if_then(is_null(builder, pointer), likely=False):
+ context.call_conv.return_user_exc(builder, MemoryError, exc_args)
+
+
+@contextmanager
+def if_zero(builder, value, likely=False):
+ """
+ Execute the given block if the scalar value is zero.
+ """
+ with builder.if_then(is_scalar_zero(builder, value), likely=likely):
+ yield
+
+
+guard_zero = guard_null
+
+
+def is_pointer(ltyp):
+ """
+ Whether the LLVM type *typ* is a struct type.
+ """
+ return isinstance(ltyp, ir.PointerType)
+
+
+def get_record_member(builder, record, offset, typ):
+ pval = gep_inbounds(builder, record, 0, offset)
+ assert not is_pointer(pval.type.pointee)
+ return builder.bitcast(pval, typ.as_pointer())
+
+
+def is_neg_int(builder, val):
+ return builder.icmp_signed('<', val, val.type(0))
+
+
+def gep_inbounds(builder, ptr, *inds, **kws):
+ """
+ Same as *gep*, but add the `inbounds` keyword.
+ """
+ return gep(builder, ptr, *inds, inbounds=True, **kws)
+
+
+def gep(builder, ptr, *inds, **kws):
+ """
+ Emit a getelementptr instruction for the given pointer and indices.
+ The indices can be LLVM values or Python int constants.
+ """
+ name = kws.pop('name', '')
+ inbounds = kws.pop('inbounds', False)
+ assert not kws
+ idx = []
+ for i in inds:
+ if isinstance(i, int):
+ # NOTE: llvm only accepts int32 inside structs, not int64
+ ind = int32_t(i)
+ else:
+ ind = i
+ idx.append(ind)
+ return builder.gep(ptr, idx, name=name, inbounds=inbounds)
+
+
+def pointer_add(builder, ptr, offset, return_type=None):
+ """
+ Add an integral *offset* to pointer *ptr*, and return a pointer
+ of *return_type* (or, if omitted, the same type as *ptr*).
+
+ Note the computation is done in bytes, and ignores the width of
+ the pointed item type.
+ """
+ intptr = builder.ptrtoint(ptr, intp_t)
+ if isinstance(offset, int):
+ offset = intp_t(offset)
+ intptr = builder.add(intptr, offset)
+ return builder.inttoptr(intptr, return_type or ptr.type)
+
+
+def memset(builder, ptr, size, value):
+ """
+ Fill *size* bytes starting from *ptr* with *value*.
+ """
+ fn = builder.module.declare_intrinsic('llvm.memset', (voidptr_t, size.type))
+ ptr = builder.bitcast(ptr, voidptr_t)
+ if isinstance(value, int):
+ value = int8_t(value)
+ builder.call(fn, [ptr, value, size, bool_t(0)])
+
+
+def memset_padding(builder, ptr):
+ """
+ Fill padding bytes of the pointee with zeros.
+ """
+ # Load existing value
+ val = builder.load(ptr)
+ # Fill pointee with zeros
+ memset(builder, ptr, sizeof(builder, ptr.type), 0)
+ # Store value back
+ builder.store(val, ptr)
+
+
+def global_constant(builder_or_module, name, value, linkage='internal'):
+ """
+ Get or create a (LLVM module-)global constant with *name* or *value*.
+ """
+ if isinstance(builder_or_module, ir.Module):
+ module = builder_or_module
+ else:
+ module = builder_or_module.module
+ data = add_global_variable(module, value.type, name)
+ data.linkage = linkage
+ data.global_constant = True
+ data.initializer = value
+ return data
+
+
+def divmod_by_constant(builder, val, divisor):
+ """
+ Compute the (quotient, remainder) of *val* divided by the constant
+ positive *divisor*. The semantics reflects those of Python integer
+ floor division, rather than C's / LLVM's signed division and modulo.
+ The difference lies with a negative *val*.
+ """
+ assert divisor > 0
+ divisor = val.type(divisor)
+ one = val.type(1)
+
+ quot = alloca_once(builder, val.type)
+
+ with builder.if_else(is_neg_int(builder, val)) as (if_neg, if_pos):
+ with if_pos:
+ # quot = val / divisor
+ quot_val = builder.sdiv(val, divisor)
+ builder.store(quot_val, quot)
+ with if_neg:
+ # quot = -1 + (val + 1) / divisor
+ val_plus_one = builder.add(val, one)
+ quot_val = builder.sdiv(val_plus_one, divisor)
+ builder.store(builder.sub(quot_val, one), quot)
+
+ # rem = val - quot * divisor
+ # (should be slightly faster than a separate modulo operation)
+ quot_val = builder.load(quot)
+ rem_val = builder.sub(val, builder.mul(quot_val, divisor))
+ return quot_val, rem_val
+
+
+def cbranch_or_continue(builder, cond, bbtrue):
+ """
+ Branch conditionally or continue.
+
+ Note: a new block is created and builder is moved to the end of the new
+ block.
+ """
+ bbcont = builder.append_basic_block('.continue')
+ builder.cbranch(cond, bbtrue, bbcont)
+ builder.position_at_end(bbcont)
+ return bbcont
+
+
+def memcpy(builder, dst, src, count):
+ """
+ Emit a memcpy to the builder.
+
+ Copies each element of dst to src. Unlike the C equivalent, each element
+ can be any LLVM type.
+
+ Assumes
+ -------
+ * dst.type == src.type
+ * count is positive
+ """
+ # Note this does seem to be optimized as a raw memcpy() by LLVM
+ # whenever possible...
+ assert dst.type == src.type
+ with for_range(builder, count, intp=count.type) as loop:
+ out_ptr = builder.gep(dst, [loop.index])
+ in_ptr = builder.gep(src, [loop.index])
+ builder.store(builder.load(in_ptr), out_ptr)
+
+
+def _raw_memcpy(builder, func_name, dst, src, count, itemsize, align):
+ size_t = count.type
+ if isinstance(itemsize, int):
+ itemsize = ir.Constant(size_t, itemsize)
+
+ memcpy = builder.module.declare_intrinsic(func_name,
+ [voidptr_t, voidptr_t, size_t])
+ is_volatile = false_bit
+ builder.call(memcpy, [builder.bitcast(dst, voidptr_t),
+ builder.bitcast(src, voidptr_t),
+ builder.mul(count, itemsize),
+ is_volatile])
+
+
+def raw_memcpy(builder, dst, src, count, itemsize, align=1):
+ """
+ Emit a raw memcpy() call for `count` items of size `itemsize`
+ from `src` to `dest`.
+ """
+ return _raw_memcpy(builder, 'llvm.memcpy', dst, src, count, itemsize, align)
+
+
+def raw_memmove(builder, dst, src, count, itemsize, align=1):
+ """
+ Emit a raw memmove() call for `count` items of size `itemsize`
+ from `src` to `dest`.
+ """
+ return _raw_memcpy(builder, 'llvm.memmove', dst, src, count,
+ itemsize, align)
+
+
+def muladd_with_overflow(builder, a, b, c):
+ """
+ Compute (a * b + c) and return a (result, overflow bit) pair.
+ The operands must be signed integers.
+ """
+ p = builder.smul_with_overflow(a, b)
+ prod = builder.extract_value(p, 0)
+ prod_ovf = builder.extract_value(p, 1)
+ s = builder.sadd_with_overflow(prod, c)
+ res = builder.extract_value(s, 0)
+ ovf = builder.or_(prod_ovf, builder.extract_value(s, 1))
+ return res, ovf
+
+
+def printf(builder, format, *args):
+ """
+ Calls printf().
+ Argument `format` is expected to be a Python string.
+ Values to be printed are listed in `args`.
+
+ Note: There is no checking to ensure there is correct number of values
+ in `args` and there type matches the declaration in the format string.
+ """
+ assert isinstance(format, str)
+ mod = builder.module
+ # Make global constant for format string
+ cstring = voidptr_t
+ fmt_bytes = make_bytearray((format + '\00').encode('ascii'))
+ global_fmt = global_constant(mod, "printf_format", fmt_bytes)
+ fnty = ir.FunctionType(int32_t, [cstring], var_arg=True)
+ # Insert printf()
+ try:
+ fn = mod.get_global('printf')
+ except KeyError:
+ fn = ir.Function(mod, fnty, name="printf")
+ # Call
+ ptr_fmt = builder.bitcast(global_fmt, cstring)
+ return builder.call(fn, [ptr_fmt] + list(args))
+
+
+def snprintf(builder, buffer, bufsz, format, *args):
+ """Calls libc snprintf(buffer, bufsz, format, ...args)
+ """
+ assert isinstance(format, str)
+ mod = builder.module
+ # Make global constant for format string
+ cstring = voidptr_t
+ fmt_bytes = make_bytearray((format + '\00').encode('ascii'))
+ global_fmt = global_constant(mod, "snprintf_format", fmt_bytes)
+ fnty = ir.FunctionType(
+ int32_t, [cstring, intp_t, cstring], var_arg=True,
+ )
+ # Actual symbol name of snprintf is different on win32.
+ symbol = 'snprintf'
+ if config.IS_WIN32:
+ symbol = '_' + symbol
+ # Insert snprintf()
+ try:
+ fn = mod.get_global(symbol)
+ except KeyError:
+ fn = ir.Function(mod, fnty, name=symbol)
+ # Call
+ ptr_fmt = builder.bitcast(global_fmt, cstring)
+ return builder.call(fn, [buffer, bufsz, ptr_fmt] + list(args))
+
+
+def snprintf_stackbuffer(builder, bufsz, format, *args):
+ """Similar to `snprintf()` but the buffer is stack allocated to size
+ *bufsz*.
+
+ Returns the buffer pointer as i8*.
+ """
+ assert isinstance(bufsz, int)
+ spacety = ir.ArrayType(ir.IntType(8), bufsz)
+ space = alloca_once(builder, spacety, zfill=True)
+ buffer = builder.bitcast(space, voidptr_t)
+ snprintf(builder, buffer, intp_t(bufsz), format, *args)
+ return buffer
+
+
+def normalize_ir_text(text):
+ """
+ Normalize the given string to latin1 compatible encoding that is
+ suitable for use in LLVM IR.
+ """
+ # Just re-encoding to latin1 is enough
+ return text.encode('utf8').decode('latin1')
+
+
+def hexdump(builder, ptr, nbytes):
+ """Debug print the memory region in *ptr* to *ptr + nbytes*
+ as hex.
+ """
+ bytes_per_line = 16
+ nbytes = builder.zext(nbytes, intp_t)
+ printf(builder, "hexdump p=%p n=%zu",
+ ptr, nbytes)
+ byte_t = ir.IntType(8)
+ ptr = builder.bitcast(ptr, byte_t.as_pointer())
+ # Loop to print the bytes in *ptr* as hex
+ with for_range(builder, nbytes) as idx:
+ div_by = builder.urem(idx.index, intp_t(bytes_per_line))
+ do_new_line = builder.icmp_unsigned("==", div_by, intp_t(0))
+ with builder.if_then(do_new_line):
+ printf(builder, "\n")
+
+ offset = builder.gep(ptr, [idx.index])
+ val = builder.load(offset)
+ printf(builder, " %02x", val)
+ printf(builder, "\n")
+
+
+def is_nonelike(ty):
+ """ returns if 'ty' is none """
+ return (
+ ty is None or
+ isinstance(ty, types.NoneType) or
+ isinstance(ty, types.Omitted)
+ )
+
+
+def is_empty_tuple(ty):
+ """ returns if 'ty' is an empty tuple """
+ return (
+ isinstance(ty, types.Tuple) and
+ len(ty.types) == 0
+ )
+
+
+def create_constant_array(ty, val):
+ """
+ Create an LLVM-constant of a fixed-length array from Python values.
+
+ The type provided is the type of the elements.
+ """
+ return ir.Constant(ir.ArrayType(ty, len(val)), val)
diff --git a/venv/lib/python3.10/site-packages/numba/core/codegen.py b/venv/lib/python3.10/site-packages/numba/core/codegen.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fe953fbb94a7ee20ccf03fdd89643375f04b0eb
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/codegen.py
@@ -0,0 +1,1457 @@
+import warnings
+import functools
+import locale
+import weakref
+import ctypes
+import html
+import textwrap
+
+import llvmlite.binding as ll
+import llvmlite.ir as llvmir
+
+from abc import abstractmethod, ABCMeta
+from numba.core import utils, config, cgutils
+from numba.core.llvm_bindings import create_pass_manager_builder
+from numba.core.runtime.nrtopt import remove_redundant_nrt_refct
+from numba.core.runtime import rtsys
+from numba.core.compiler_lock import require_global_compiler_lock
+from numba.core.errors import NumbaInvalidConfigWarning
+from numba.misc.inspection import disassemble_elf_to_cfg
+from numba.misc.llvm_pass_timings import PassTimingsCollection
+
+
+_x86arch = frozenset(['x86', 'i386', 'i486', 'i586', 'i686', 'i786',
+ 'i886', 'i986'])
+
+
+def _is_x86(triple):
+ arch = triple.split('-')[0]
+ return arch in _x86arch
+
+
+def _parse_refprune_flags():
+ """Parse refprune flags from the `config`.
+
+ Invalid values are ignored an warn via a `NumbaInvalidConfigWarning`
+ category.
+
+ Returns
+ -------
+ flags : llvmlite.binding.RefPruneSubpasses
+ """
+ flags = config.LLVM_REFPRUNE_FLAGS.split(',')
+ if not flags:
+ return 0
+ val = 0
+ for item in flags:
+ item = item.strip()
+ try:
+ val |= getattr(ll.RefPruneSubpasses, item.upper())
+ except AttributeError:
+ warnings.warn(f"invalid refprune flags {item!r}",
+ NumbaInvalidConfigWarning)
+ return val
+
+
+def dump(header, body, lang):
+ if config.HIGHLIGHT_DUMPS:
+ try:
+ import pygments
+ except ImportError:
+ msg = "Please install pygments to see highlighted dumps"
+ raise ValueError(msg)
+ else:
+ from pygments import highlight
+ from pygments.lexers import GasLexer as gas_lexer
+ from pygments.lexers import LlvmLexer as llvm_lexer
+ from pygments.formatters import Terminal256Formatter
+ from numba.misc.dump_style import by_colorscheme
+
+ lexer_map = {'llvm': llvm_lexer, 'asm': gas_lexer}
+ lexer = lexer_map[lang]
+ def printer(arg):
+ print(highlight(arg, lexer(),
+ Terminal256Formatter(style=by_colorscheme())))
+ else:
+ printer = print
+ print('=' * 80)
+ print(header.center(80, '-'))
+ printer(body)
+ print('=' * 80)
+
+
+class _CFG(object):
+ """
+ Wraps the CFG graph for different display method.
+
+ Instance of the class can be stringified (``__repr__`` is defined) to get
+ the graph in DOT format. The ``.display()`` method plots the graph in
+ PDF. If in IPython notebook, the returned image can be inlined.
+ """
+ def __init__(self, cres, name, py_func, **kwargs):
+ self.cres = cres
+ self.name = name
+ self.py_func = py_func
+ fn = cres.get_function(name)
+ self.dot = ll.get_function_cfg(fn)
+ self.kwargs = kwargs
+
+ def pretty_printer(self, filename=None, view=None, render_format=None,
+ highlight=True,
+ interleave=False, strip_ir=False, show_key=True,
+ fontsize=10):
+ """
+ "Pretty" prints the DOT graph of the CFG.
+ For explanation of the parameters see the docstring for
+ numba.core.dispatcher::inspect_cfg.
+ """
+ import graphviz as gv
+ import re
+ import json
+ import inspect
+ from llvmlite import binding as ll
+ from numba.typed import List
+ from types import SimpleNamespace
+ from collections import defaultdict
+
+ _default = False
+ _highlight = SimpleNamespace(incref=_default,
+ decref=_default,
+ returns=_default,
+ raises=_default,
+ meminfo=_default,
+ branches=_default,
+ llvm_intrin_calls=_default,
+ function_calls=_default,)
+ _interleave = SimpleNamespace(python=_default, lineinfo=_default)
+
+ def parse_config(_config, kwarg):
+ """ Parses the kwarg into a consistent format for use in configuring
+ the Digraph rendering. _config is the configuration instance to
+ update, kwarg is the kwarg on which to base the updates.
+ """
+ if isinstance(kwarg, bool):
+ for attr in _config.__dict__:
+ setattr(_config, attr, kwarg)
+ elif isinstance(kwarg, dict):
+ for k, v in kwarg.items():
+ if k not in _config.__dict__:
+ raise ValueError("Unexpected key in kwarg: %s" % k)
+ if isinstance(v, bool):
+ setattr(_config, k, v)
+ else:
+ msg = "Unexpected value for key: %s, got:%s"
+ raise ValueError(msg % (k, v))
+ elif isinstance(kwarg, set):
+ for item in kwarg:
+ if item not in _config.__dict__:
+ raise ValueError("Unexpected key in kwarg: %s" % item)
+ else:
+ setattr(_config, item, True)
+ else:
+ msg = "Unhandled configuration type for kwarg %s"
+ raise ValueError(msg % type(kwarg))
+
+ parse_config(_highlight, highlight)
+ parse_config(_interleave, interleave)
+
+ # This is the colour scheme. The graphviz HTML label renderer only takes
+ # names for colours: https://www.graphviz.org/doc/info/shapes.html#html
+ cs = defaultdict(lambda: 'white') # default bg colour is white
+ cs['marker'] = 'orange'
+ cs['python'] = 'yellow'
+ cs['truebr'] = 'green'
+ cs['falsebr'] = 'red'
+ cs['incref'] = 'cyan'
+ cs['decref'] = 'turquoise'
+ cs['raise'] = 'lightpink'
+ cs['meminfo'] = 'lightseagreen'
+ cs['return'] = 'purple'
+ cs['llvm_intrin_calls'] = 'rosybrown'
+ cs['function_calls'] = 'tomato'
+
+ # Get the raw dot format information from LLVM and the LLVM IR
+ fn = self.cres.get_function(self.name)
+ #raw_dot = ll.get_function_cfg(fn).replace('\\l...', '')
+ llvm_str = self.cres.get_llvm_str()
+
+ def get_metadata(llvm_str):
+ """ Gets the metadata entries from the LLVM IR, these look something
+ like '!123 = INFORMATION'. Returns a map of metadata key to metadata
+ value, i.e. from the example {'!123': INFORMATION}"""
+ md = {}
+ metadata_entry = re.compile(r'(^[!][0-9]+)(\s+=\s+.*)')
+ for x in llvm_str.splitlines():
+ match = metadata_entry.match(x)
+ if match is not None:
+ g = match.groups()
+ if g is not None:
+ assert len(g) == 2
+ md[g[0]] = g[1]
+ return md
+
+ md = get_metadata(llvm_str)
+
+ # setup digraph with initial properties
+ def init_digraph(name, fname, fontsize):
+ # name and fname are arbitrary graph and file names, they appear in
+ # some rendering formats, the fontsize determines the output
+ # fontsize.
+
+ # truncate massive mangled names as file names as it causes OSError
+ # when trying to render to pdf
+ cmax = 200
+ if len(fname) > cmax:
+ wstr = (f'CFG output filename "{fname}" exceeds maximum '
+ f'supported length, it will be truncated.')
+ warnings.warn(wstr, NumbaInvalidConfigWarning)
+ fname = fname[:cmax]
+ f = gv.Digraph(name, filename=fname)
+ f.attr(rankdir='TB')
+ f.attr('node', shape='none', fontsize='%s' % str(fontsize))
+ return f
+
+ f = init_digraph(self.name, self.name, fontsize)
+
+ # A lot of regex is needed to parse the raw dot output. This output
+ # contains a mix of LLVM IR in the labels, and also DOT markup.
+
+ # DOT syntax, matches a "port" (where the tail of an edge starts)
+ port_match = re.compile('.*{(.*)}.*')
+ # DOT syntax, matches the "port" value from a found "port_match"
+ port_jmp_match = re.compile('.*<(.*)>(.*)')
+ # LLVM syntax, matches a LLVM debug marker
+ metadata_marker = re.compile(r'.*!dbg\s+(![0-9]+).*')
+ # LLVM syntax, matches a location entry
+ location_expr = (r'.*!DILocation\(line:\s+([0-9]+),'
+ r'\s+column:\s+([0-9]),.*')
+ location_entry = re.compile(location_expr)
+ # LLVM syntax, matches LLVMs internal debug value calls
+ dbg_value = re.compile(r'.*call void @llvm.dbg.value.*')
+ # LLVM syntax, matches tokens for highlighting
+ nrt_incref = re.compile(r"@NRT_incref\b")
+ nrt_decref = re.compile(r"@NRT_decref\b")
+ nrt_meminfo = re.compile("@NRT_MemInfo")
+ ll_intrin_calls = re.compile(r".*call.*@llvm\..*")
+ ll_function_call = re.compile(r".*call.*@.*")
+ ll_raise = re.compile(r"store .*\!numba_exception_output.*")
+ ll_return = re.compile("ret i32 [^1],?.*")
+
+ # wrapper function for line wrapping LLVM lines
+ def wrap(s):
+ return textwrap.wrap(s, width=120, subsequent_indent='... ')
+
+ # function to fix (sometimes escaped for DOT!) LLVM IR etc that needs to
+ # be HTML escaped
+ def clean(s):
+ # Grab first 300 chars only, 1. this should be enough to identify
+ # the token and it keeps names short. 2. graphviz/dot has a maximum
+ # buffer size near 585?!, with additional transforms it's hard to
+ # know if this would be exceeded. 3. hash of the token string is
+ # written into the rendering to permit exact identification against
+ # e.g. LLVM IR dump if necessary.
+ n = 300
+ if len(s) > n:
+ hs = str(hash(s))
+ s = '{}...'.format(s[:n], hs)
+ s = html.escape(s) # deals with &, < and >
+ s = s.replace('\\{', "{")
+ s = s.replace('\\}', "}")
+ s = s.replace('\\', "\")
+ s = s.replace('%', "%")
+ s = s.replace('!', "!")
+ return s
+
+ # These hold the node and edge ids from the raw dot information. They
+ # are used later to wire up a new DiGraph that has the same structure
+ # as the raw dot but with new nodes.
+ node_ids = {}
+ edge_ids = {}
+
+ # Python source lines, used if python source interleave is requested
+ if _interleave.python:
+ src_code, firstlineno = inspect.getsourcelines(self.py_func)
+
+ # This is the dot info from LLVM, it's in DOT form and has continuation
+ # lines, strip them and then re-parse into `dot_json` form for use in
+ # producing a formatted output.
+ raw_dot = ll.get_function_cfg(fn).replace('\\l...', '')
+ json_bytes = gv.Source(raw_dot).pipe(format='dot_json')
+ jzon = json.loads(json_bytes.decode('utf-8'))
+
+ idc = 0
+ # Walk the "objects" (nodes) in the DOT output
+ for obj in jzon['objects']:
+ # These are used to keep tabs on the current line and column numbers
+ # as per the markers. They are tracked so as to make sure a marker
+ # is only emitted if there's a change in the marker.
+ cur_line, cur_col = -1, -1
+ label = obj['label']
+ name = obj['name']
+ gvid = obj['_gvid']
+ node_ids[gvid] = name
+ # Label is DOT format, it needs the head and tail removing and then
+ # splitting for walking.
+ label = label[1:-1]
+ lines = label.split('\\l')
+
+ # Holds the new lines
+ new_lines = []
+
+ # Aim is to produce an HTML table a bit like this:
+ #
+ # |------------|
+ # | HEADER | <-- this is the block header
+ # |------------|
+ # | LLVM SRC | <--
+ # | Marker? | < this is the label/block body
+ # | Python src?| <--
+ # |------------|
+ # | T | F | <-- this is the "ports", also determines col_span
+ # --------------
+ #
+
+ # This is HTML syntax, its the column span. If there's a switch or a
+ # branch at the bottom of the node this is rendered as multiple
+ # columns in a table. First job is to go and render that and work
+ # out how many columns are needed as that dictates how many columns
+ # the rest of the source lines must span. In DOT syntax the places
+ # that edges join nodes are referred to as "ports". Syntax in DOT
+ # is like `node:port`.
+ col_span = 1
+
+ # First see if there is a port entry for this node
+ port_line = ''
+ matched = port_match.match(lines[-1])
+ sliced_lines = lines
+ if matched is not None:
+ # There is a port
+ ports = matched.groups()[0]
+ ports_tokens = ports.split('|')
+ col_span = len(ports_tokens)
+ # Generate HTML table data cells, one for each port. If the
+ # ports correspond to a branch then they can optionally
+ # highlighted based on T/F.
+ tdfmt = ('
{}
')
+ tbl_data = []
+ if _highlight.branches:
+ colors = {'T': cs['truebr'], 'F': cs['falsebr']}
+ else:
+ colors = {}
+ for tok in ports_tokens:
+ target, value = port_jmp_match.match(tok).groups()
+ color = colors.get(value, 'white')
+ tbl_data.append(tdfmt.format(color, target, value))
+ port_line = ''.join(tbl_data)
+ # Drop the last line from the rest of the parse as it's the port
+ # and just been dealt with.
+ sliced_lines = lines[:-1]
+
+ # loop peel the block header, it needs a HTML border
+ fmtheader = ('
{}
')
+ new_lines.append(fmtheader.format(cs['default'], col_span,
+ clean(sliced_lines[0].strip())))
+
+ # process rest of block creating the table row at a time.
+ fmt = ('
{}
')
+
+ def metadata_interleave(l, new_lines):
+ """
+ Search line `l` for metadata associated with python or line info
+ and inject it into `new_lines` if requested.
+ """
+ matched = metadata_marker.match(l)
+ if matched is not None:
+ # there's a metadata marker
+ g = matched.groups()
+ if g is not None:
+ assert len(g) == 1, g
+ marker = g[0]
+ debug_data = md.get(marker, None)
+ if debug_data is not None:
+ # and the metadata marker has a corresponding piece
+ # of metadata
+ ld = location_entry.match(debug_data)
+ if ld is not None:
+ # and the metadata is line info... proceed
+ assert len(ld.groups()) == 2, ld
+ line, col = ld.groups()
+ # only emit a new marker if the line number in
+ # the metadata is "new".
+ if line != cur_line or col != cur_col:
+ if _interleave.lineinfo:
+ mfmt = 'Marker %s, Line %s, column %s'
+ mark_line = mfmt % (marker, line, col)
+ ln = fmt.format(cs['marker'], col_span,
+ clean(mark_line))
+ new_lines.append(ln)
+ if _interleave.python:
+ # TODO:
+ # +1 for decorator, this probably needs
+ # the same thing doing as for the
+ # error messages where the decorator
+ # is scanned for, its not always +1!
+ lidx = int(line) - (firstlineno + 1)
+ source_line = src_code[lidx + 1]
+ ln = fmt.format(cs['python'], col_span,
+ clean(source_line))
+ new_lines.append(ln)
+ return line, col
+
+ for l in sliced_lines[1:]:
+
+ # Drop LLVM debug call entries
+ if dbg_value.match(l):
+ continue
+
+ # if requested generate interleaving of markers or python from
+ # metadata
+ if _interleave.lineinfo or _interleave.python:
+ updated_lineinfo = metadata_interleave(l, new_lines)
+ if updated_lineinfo is not None:
+ cur_line, cur_col = updated_lineinfo
+
+ # Highlight other LLVM features if requested, HTML BGCOLOR
+ # property is set by this.
+ if _highlight.incref and nrt_incref.search(l):
+ colour = cs['incref']
+ elif _highlight.decref and nrt_decref.search(l):
+ colour = cs['decref']
+ elif _highlight.meminfo and nrt_meminfo.search(l):
+ colour = cs['meminfo']
+ elif _highlight.raises and ll_raise.search(l):
+ # search for raise as its more specific than exit
+ colour = cs['raise']
+ elif _highlight.returns and ll_return.search(l):
+ colour = cs['return']
+ elif _highlight.llvm_intrin_calls and ll_intrin_calls.search(l):
+ colour = cs['llvm_intrin_calls']
+ elif _highlight.function_calls and ll_function_call.search(l):
+ colour = cs['function_calls']
+ else:
+ colour = cs['default']
+
+ # Use the default coloring as a flag to force printing if a
+ # special token print was requested AND LLVM ir stripping is
+ # required
+ if colour is not cs['default'] or not strip_ir:
+ for x in wrap(clean(l)):
+ new_lines.append(fmt.format(colour, col_span, x))
+
+ # add in the port line at the end of the block if it was present
+ # (this was built right at the top of the parse)
+ if port_line:
+ new_lines.append('
{}
'.format(port_line))
+
+ # If there was data, create a table, else don't!
+ dat = ''.join(new_lines)
+ if dat:
+ tab = (('
%s
') % (idc,
+ dat))
+ label = '<{}>'.format(tab)
+ else:
+ label = ''
+
+ # finally, add a replacement node for the original with a new marked
+ # up label.
+ f.node(name, label=label)
+
+ # Parse the edge data
+ if 'edges' in jzon: # might be a single block, no edges
+ for edge in jzon['edges']:
+ gvid = edge['_gvid']
+ tp = edge.get('tailport', None)
+ edge_ids[gvid] = (edge['head'], edge['tail'], tp)
+
+ # Write in the edge wiring with respect to the new nodes:ports.
+ for gvid, edge in edge_ids.items():
+ tail = node_ids[edge[1]]
+ head = node_ids[edge[0]]
+ port = edge[2]
+ if port is not None:
+ tail += ':%s' % port
+ f.edge(tail, head)
+
+ # Add a key to the graph if requested.
+ if show_key:
+ key_tab = []
+ for k, v in cs.items():
+ key_tab.append(('
{}
').format(v, k))
+ # The first < and last > are DOT syntax, rest is DOT HTML.
+ f.node("Key", label=('<
'
+ 'Key:
{}
>').format(''.join(key_tab)))
+
+ # Render if required
+ if filename is not None or view is not None:
+ f.render(filename=filename, view=view, format=render_format)
+
+ # Else pipe out a SVG
+ return f.pipe(format='svg')
+
+ def display(self, filename=None, format='pdf', view=False):
+ """
+ Plot the CFG. In IPython notebook, the return image object can be
+ inlined.
+
+ The *filename* option can be set to a specific path for the rendered
+ output to write to. If *view* option is True, the plot is opened by
+ the system default application for the image format (PDF). *format* can
+ be any valid format string accepted by graphviz, default is 'pdf'.
+ """
+ rawbyt = self.pretty_printer(filename=filename, view=view,
+ render_format=format, **self.kwargs)
+ return rawbyt.decode('utf-8')
+
+ def _repr_svg_(self):
+ return self.pretty_printer(**self.kwargs).decode('utf-8')
+
+ def __repr__(self):
+ return self.dot
+
+
+class CodeLibrary(metaclass=ABCMeta):
+ """
+ An interface for bundling LLVM code together and compiling it.
+ It is tied to a *codegen* instance (e.g. JITCPUCodegen) that will
+ determine how the LLVM code is transformed and linked together.
+ """
+
+ _finalized = False
+ _object_caching_enabled = False
+ _disable_inspection = False
+
+ def __init__(self, codegen: "CPUCodegen", name: str):
+ self._codegen = codegen
+ self._name = name
+ ptc_name = f"{self.__class__.__name__}({self._name!r})"
+ self._recorded_timings = PassTimingsCollection(ptc_name)
+ # Track names of the dynamic globals
+ self._dynamic_globals = []
+
+ @property
+ def has_dynamic_globals(self):
+ self._ensure_finalized()
+ return len(self._dynamic_globals) > 0
+
+ @property
+ def recorded_timings(self):
+ return self._recorded_timings
+
+ @property
+ def codegen(self):
+ """
+ The codegen object owning this library.
+ """
+ return self._codegen
+
+ @property
+ def name(self):
+ return self._name
+
+ def __repr__(self):
+ return "" % (self.name, id(self))
+
+ def _raise_if_finalized(self):
+ if self._finalized:
+ raise RuntimeError("operation impossible on finalized object %r"
+ % (self,))
+
+ def _ensure_finalized(self):
+ if not self._finalized:
+ self.finalize()
+
+ def create_ir_module(self, name):
+ """
+ Create an LLVM IR module for use by this library.
+ """
+ self._raise_if_finalized()
+ ir_module = self._codegen._create_empty_module(name)
+ return ir_module
+
+ @abstractmethod
+ def add_linking_library(self, library):
+ """
+ Add a library for linking into this library, without losing
+ the original library.
+ """
+
+ @abstractmethod
+ def add_ir_module(self, ir_module):
+ """
+ Add an LLVM IR module's contents to this library.
+ """
+
+ @abstractmethod
+ def finalize(self):
+ """
+ Finalize the library. After this call, nothing can be added anymore.
+ Finalization involves various stages of code optimization and
+ linking.
+ """
+
+ @abstractmethod
+ def get_function(self, name):
+ """
+ Return the function named ``name``.
+ """
+
+ @abstractmethod
+ def get_llvm_str(self):
+ """
+ Get the human-readable form of the LLVM module.
+ """
+
+ @abstractmethod
+ def get_asm_str(self):
+ """
+ Get the human-readable assembly.
+ """
+
+ #
+ # Object cache hooks and serialization
+ #
+
+ def enable_object_caching(self):
+ self._object_caching_enabled = True
+ self._compiled_object = None
+ self._compiled = False
+
+ def _get_compiled_object(self):
+ if not self._object_caching_enabled:
+ raise ValueError("object caching not enabled in %s" % (self,))
+ if self._compiled_object is None:
+ raise RuntimeError("no compiled object yet for %s" % (self,))
+ return self._compiled_object
+
+ def _set_compiled_object(self, value):
+ if not self._object_caching_enabled:
+ raise ValueError("object caching not enabled in %s" % (self,))
+ if self._compiled:
+ raise ValueError("library already compiled: %s" % (self,))
+ self._compiled_object = value
+ self._disable_inspection = True
+
+
+class CPUCodeLibrary(CodeLibrary):
+
+ def __init__(self, codegen, name):
+ super().__init__(codegen, name)
+ self._linking_libraries = [] # maintain insertion order
+ self._final_module = ll.parse_assembly(
+ str(self._codegen._create_empty_module(self.name)))
+ self._final_module.name = cgutils.normalize_ir_text(self.name)
+ self._shared_module = None
+
+ def _optimize_functions(self, ll_module):
+ """
+ Internal: run function-level optimizations inside *ll_module*.
+ """
+ # Enforce data layout to enable layout-specific optimizations
+ ll_module.data_layout = self._codegen._data_layout
+ with self._codegen._function_pass_manager(ll_module) as fpm:
+ # Run function-level optimizations to reduce memory usage and improve
+ # module-level optimization.
+ for func in ll_module.functions:
+ k = f"Function passes on {func.name!r}"
+ with self._recorded_timings.record(k):
+ fpm.initialize()
+ fpm.run(func)
+ fpm.finalize()
+
+ def _optimize_final_module(self):
+ """
+ Internal: optimize this library's final module.
+ """
+
+ mpm_cheap = self._codegen._module_pass_manager(loop_vectorize=self._codegen._loopvect,
+ slp_vectorize=False,
+ opt=self._codegen._opt_level,
+ cost="cheap")
+
+ mpm_full = self._codegen._module_pass_manager()
+
+ cheap_name = "Module passes (cheap optimization for refprune)"
+ with self._recorded_timings.record(cheap_name):
+ # A cheaper optimisation pass is run first to try and get as many
+ # refops into the same function as possible via inlining
+ mpm_cheap.run(self._final_module)
+ # Refop pruning is then run on the heavily inlined function
+ if not config.LLVM_REFPRUNE_PASS:
+ self._final_module = remove_redundant_nrt_refct(self._final_module)
+ full_name = "Module passes (full optimization)"
+ with self._recorded_timings.record(full_name):
+ # The full optimisation suite is then run on the refop pruned IR
+ mpm_full.run(self._final_module)
+
+ def _get_module_for_linking(self):
+ """
+ Internal: get a LLVM module suitable for linking multiple times
+ into another library. Exported functions are made "linkonce_odr"
+ to allow for multiple definitions, inlining, and removal of
+ unused exports.
+
+ See discussion in https://github.com/numba/numba/pull/890
+ """
+ self._ensure_finalized()
+ if self._shared_module is not None:
+ return self._shared_module
+ mod = self._final_module
+ to_fix = []
+ nfuncs = 0
+ for fn in mod.functions:
+ nfuncs += 1
+ if not fn.is_declaration and fn.linkage == ll.Linkage.external:
+ to_fix.append(fn.name)
+ if nfuncs == 0:
+ # This is an issue which can occur if loading a module
+ # from an object file and trying to link with it, so detect it
+ # here to make debugging easier.
+ raise RuntimeError("library unfit for linking: "
+ "no available functions in %s"
+ % (self,))
+ if to_fix:
+ mod = mod.clone()
+ for name in to_fix:
+ # NOTE: this will mark the symbol WEAK if serialized
+ # to an ELF file
+ mod.get_function(name).linkage = 'linkonce_odr'
+ self._shared_module = mod
+ return mod
+
+ def add_linking_library(self, library):
+ library._ensure_finalized()
+ self._linking_libraries.append(library)
+
+ def add_ir_module(self, ir_module):
+ self._raise_if_finalized()
+ assert isinstance(ir_module, llvmir.Module)
+ ir = cgutils.normalize_ir_text(str(ir_module))
+ ll_module = ll.parse_assembly(ir)
+ ll_module.name = ir_module.name
+ ll_module.verify()
+ self.add_llvm_module(ll_module)
+
+ def add_llvm_module(self, ll_module):
+ self._optimize_functions(ll_module)
+ # TODO: we shouldn't need to recreate the LLVM module object
+ if not config.LLVM_REFPRUNE_PASS:
+ ll_module = remove_redundant_nrt_refct(ll_module)
+ self._final_module.link_in(ll_module)
+
+ def finalize(self):
+ require_global_compiler_lock()
+
+ # Report any LLVM-related problems to the user
+ self._codegen._check_llvm_bugs()
+
+ self._raise_if_finalized()
+
+ if config.DUMP_FUNC_OPT:
+ dump("FUNCTION OPTIMIZED DUMP %s" % self.name,
+ self.get_llvm_str(), 'llvm')
+
+ # Link libraries for shared code
+ seen = set()
+ for library in self._linking_libraries:
+ if library not in seen:
+ seen.add(library)
+ self._final_module.link_in(
+ library._get_module_for_linking(), preserve=True,
+ )
+
+ # Optimize the module after all dependences are linked in above,
+ # to allow for inlining.
+ self._optimize_final_module()
+
+ self._final_module.verify()
+ self._finalize_final_module()
+
+ def _finalize_dynamic_globals(self):
+ # Scan for dynamic globals
+ for gv in self._final_module.global_variables:
+ if gv.name.startswith('numba.dynamic.globals'):
+ self._dynamic_globals.append(gv.name)
+
+ def _verify_declare_only_symbols(self):
+ # Verify that no declare-only function compiled by numba.
+ for fn in self._final_module.functions:
+ # We will only check for symbol name starting with '_ZN5numba'
+ if fn.is_declaration and fn.name.startswith('_ZN5numba'):
+ msg = 'Symbol {} not linked properly'
+ raise AssertionError(msg.format(fn.name))
+
+ def _finalize_final_module(self):
+ """
+ Make the underlying LLVM module ready to use.
+ """
+ self._finalize_dynamic_globals()
+ self._verify_declare_only_symbols()
+
+ # Remember this on the module, for the object cache hooks
+ self._final_module.__library = weakref.proxy(self)
+
+ # It seems add_module() must be done only here and not before
+ # linking in other modules, otherwise get_pointer_to_function()
+ # could fail.
+ cleanup = self._codegen._add_module(self._final_module)
+ if cleanup:
+ weakref.finalize(self, cleanup)
+ self._finalize_specific()
+
+ self._finalized = True
+
+ if config.DUMP_OPTIMIZED:
+ dump("OPTIMIZED DUMP %s" % self.name, self.get_llvm_str(), 'llvm')
+
+ if config.DUMP_ASSEMBLY:
+ dump("ASSEMBLY %s" % self.name, self.get_asm_str(), 'asm')
+
+ def get_defined_functions(self):
+ """
+ Get all functions defined in the library. The library must have
+ been finalized.
+ """
+ mod = self._final_module
+ for fn in mod.functions:
+ if not fn.is_declaration:
+ yield fn
+
+ def get_function(self, name):
+ return self._final_module.get_function(name)
+
+ def _sentry_cache_disable_inspection(self):
+ if self._disable_inspection:
+ warnings.warn('Inspection disabled for cached code. '
+ 'Invalid result is returned.')
+
+ def get_llvm_str(self):
+ self._sentry_cache_disable_inspection()
+ return str(self._final_module)
+
+ def get_asm_str(self):
+ self._sentry_cache_disable_inspection()
+ return str(self._codegen._tm.emit_assembly(self._final_module))
+
+ def get_function_cfg(self, name, py_func=None, **kwargs):
+ """
+ Get control-flow graph of the LLVM function
+ """
+ self._sentry_cache_disable_inspection()
+ return _CFG(self, name, py_func, **kwargs)
+
+ def get_disasm_cfg(self, mangled_name):
+ """
+ Get the CFG of the disassembly of the ELF object at symbol mangled_name.
+
+ Requires python package: r2pipe
+ Requires radare2 binary on $PATH.
+ Notebook rendering requires python package: graphviz
+ Optionally requires a compiler toolchain (via pycc) to link the ELF to
+ get better disassembly results.
+ """
+ elf = self._get_compiled_object()
+ return disassemble_elf_to_cfg(elf, mangled_name)
+
+ @classmethod
+ def _dump_elf(cls, buf):
+ """
+ Dump the symbol table of an ELF file.
+ Needs pyelftools (https://github.com/eliben/pyelftools)
+ """
+ from elftools.elf.elffile import ELFFile
+ from elftools.elf import descriptions
+ from io import BytesIO
+ f = ELFFile(BytesIO(buf))
+ print("ELF file:")
+ for sec in f.iter_sections():
+ if sec['sh_type'] == 'SHT_SYMTAB':
+ symbols = sorted(sec.iter_symbols(), key=lambda sym: sym.name)
+ print(" symbols:")
+ for sym in symbols:
+ if not sym.name:
+ continue
+ print(" - %r: size=%d, value=0x%x, type=%s, bind=%s"
+ % (sym.name.decode(),
+ sym['st_size'],
+ sym['st_value'],
+ descriptions.describe_symbol_type(sym['st_info']['type']),
+ descriptions.describe_symbol_bind(sym['st_info']['bind']),
+ ))
+ print()
+
+ @classmethod
+ def _object_compiled_hook(cls, ll_module, buf):
+ """
+ `ll_module` was compiled into object code `buf`.
+ """
+ try:
+ self = ll_module.__library
+ except AttributeError:
+ return
+ if self._object_caching_enabled:
+ self._compiled = True
+ self._compiled_object = buf
+
+ @classmethod
+ def _object_getbuffer_hook(cls, ll_module):
+ """
+ Return a cached object code for `ll_module`.
+ """
+ try:
+ self = ll_module.__library
+ except AttributeError:
+ return
+ if self._object_caching_enabled and self._compiled_object:
+ buf = self._compiled_object
+ self._compiled_object = None
+ return buf
+
+ def serialize_using_bitcode(self):
+ """
+ Serialize this library using its bitcode as the cached representation.
+ """
+ self._ensure_finalized()
+ return (self.name, 'bitcode', self._final_module.as_bitcode())
+
+ def serialize_using_object_code(self):
+ """
+ Serialize this library using its object code as the cached
+ representation. We also include its bitcode for further inlining
+ with other libraries.
+ """
+ self._ensure_finalized()
+ data = (self._get_compiled_object(),
+ self._get_module_for_linking().as_bitcode())
+ return (self.name, 'object', data)
+
+ @classmethod
+ def _unserialize(cls, codegen, state):
+ name, kind, data = state
+ self = codegen.create_library(name)
+ assert isinstance(self, cls)
+ if kind == 'bitcode':
+ # No need to re-run optimizations, just make the module ready
+ self._final_module = ll.parse_bitcode(data)
+ self._finalize_final_module()
+ return self
+ elif kind == 'object':
+ object_code, shared_bitcode = data
+ self.enable_object_caching()
+ self._set_compiled_object(object_code)
+ self._shared_module = ll.parse_bitcode(shared_bitcode)
+ self._finalize_final_module()
+ # Load symbols from cache
+ self._codegen._engine._load_defined_symbols(self._shared_module)
+ return self
+ else:
+ raise ValueError("unsupported serialization kind %r" % (kind,))
+
+
+class AOTCodeLibrary(CPUCodeLibrary):
+
+ def emit_native_object(self):
+ """
+ Return this library as a native object (a bytestring) -- for example
+ ELF under Linux.
+
+ This function implicitly calls .finalize().
+ """
+ self._ensure_finalized()
+ return self._codegen._tm.emit_object(self._final_module)
+
+ def emit_bitcode(self):
+ """
+ Return this library as LLVM bitcode (a bytestring).
+
+ This function implicitly calls .finalize().
+ """
+ self._ensure_finalized()
+ return self._final_module.as_bitcode()
+
+ def _finalize_specific(self):
+ pass
+
+
+class JITCodeLibrary(CPUCodeLibrary):
+
+ def get_pointer_to_function(self, name):
+ """
+ Generate native code for function named *name* and return a pointer
+ to the start of the function (as an integer).
+
+ This function implicitly calls .finalize().
+
+ Returns
+ -------
+ pointer : int
+ - zero (null) if no symbol of *name* is defined by this code
+ library.
+ - non-zero if the symbol is defined.
+ """
+ self._ensure_finalized()
+ ee = self._codegen._engine
+ if not ee.is_symbol_defined(name):
+ return 0
+ else:
+ return self._codegen._engine.get_function_address(name)
+
+ def _finalize_specific(self):
+ self._codegen._scan_and_fix_unresolved_refs(self._final_module)
+ with self._recorded_timings.record("Finalize object"):
+ self._codegen._engine.finalize_object()
+
+
+class RuntimeLinker(object):
+ """
+ For tracking unresolved symbols generated at runtime due to recursion.
+ """
+ PREFIX = '.numba.unresolved$'
+
+ def __init__(self):
+ self._unresolved = utils.UniqueDict()
+ self._defined = set()
+ self._resolved = []
+
+ def scan_unresolved_symbols(self, module, engine):
+ """
+ Scan and track all unresolved external symbols in the module and
+ allocate memory for it.
+ """
+ prefix = self.PREFIX
+
+ for gv in module.global_variables:
+ if gv.name.startswith(prefix):
+ sym = gv.name[len(prefix):]
+ # Avoid remapping to existing GV
+ if engine.is_symbol_defined(gv.name):
+ continue
+ # Allocate a memory space for the pointer
+ abortfn = rtsys.library.get_pointer_to_function("nrt_unresolved_abort")
+ ptr = ctypes.c_void_p(abortfn)
+ engine.add_global_mapping(gv, ctypes.addressof(ptr))
+ self._unresolved[sym] = ptr
+
+ def scan_defined_symbols(self, module):
+ """
+ Scan and track all defined symbols.
+ """
+ for fn in module.functions:
+ if not fn.is_declaration:
+ self._defined.add(fn.name)
+
+ def resolve(self, engine):
+ """
+ Fix unresolved symbols if they are defined.
+ """
+ # An iterator to get all unresolved but available symbols
+ pending = [name for name in self._unresolved if name in self._defined]
+ # Resolve pending symbols
+ for name in pending:
+ # Get runtime address
+ fnptr = engine.get_function_address(name)
+ # Fix all usage
+ ptr = self._unresolved[name]
+ ptr.value = fnptr
+ self._resolved.append((name, ptr)) # keep ptr alive
+ # Delete resolved
+ del self._unresolved[name]
+
+def _proxy(old):
+ @functools.wraps(old)
+ def wrapper(self, *args, **kwargs):
+ return old(self._ee, *args, **kwargs)
+ return wrapper
+
+
+class JitEngine(object):
+ """Wraps an ExecutionEngine to provide custom symbol tracking.
+ Since the symbol tracking is incomplete (doesn't consider
+ loaded code object), we are not putting it in llvmlite.
+ """
+ def __init__(self, ee):
+ self._ee = ee
+ # Track symbol defined via codegen'd Module
+ # but not any cached object.
+ # NOTE: `llvm::ExecutionEngine` will catch duplicated symbols and
+ # we are not going to protect against that. A proper duplicated
+ # symbol detection will need a more logic to check for the linkage
+ # (e.g. like `weak` linkage symbol can override). This
+ # `_defined_symbols` set will be just enough to tell if a symbol
+ # exists and will not cause the `EE` symbol lookup to `exit(1)`
+ # when symbol-not-found.
+ self._defined_symbols = set()
+
+ def is_symbol_defined(self, name):
+ """Is the symbol defined in this session?
+ """
+ return name in self._defined_symbols
+
+ def _load_defined_symbols(self, mod):
+ """Extract symbols from the module
+ """
+ for gsets in (mod.functions, mod.global_variables):
+ self._defined_symbols |= {gv.name for gv in gsets
+ if not gv.is_declaration}
+
+ def add_module(self, module):
+ """Override ExecutionEngine.add_module
+ to keep info about defined symbols.
+ """
+ self._load_defined_symbols(module)
+ return self._ee.add_module(module)
+
+ def add_global_mapping(self, gv, addr):
+ """Override ExecutionEngine.add_global_mapping
+ to keep info about defined symbols.
+ """
+ self._defined_symbols.add(gv.name)
+ return self._ee.add_global_mapping(gv, addr)
+
+ #
+ # The remaining methods are re-export of the ExecutionEngine APIs
+ #
+ set_object_cache = _proxy(ll.ExecutionEngine.set_object_cache)
+ finalize_object = _proxy(ll.ExecutionEngine.finalize_object)
+ get_function_address = _proxy(ll.ExecutionEngine.get_function_address)
+ get_global_value_address = _proxy(
+ ll.ExecutionEngine.get_global_value_address
+ )
+
+
+class Codegen(metaclass=ABCMeta):
+ """
+ Base Codegen class. It is expected that subclasses set the class attribute
+ ``_library_class``, indicating the CodeLibrary class for the target.
+
+ Subclasses should also initialize:
+
+ ``self._data_layout``: the data layout for the target.
+ ``self._target_data``: the binding layer ``TargetData`` for the target.
+ """
+
+ @abstractmethod
+ def _create_empty_module(self, name):
+ """
+ Create a new empty module suitable for the target.
+ """
+
+ @abstractmethod
+ def _add_module(self, module):
+ """
+ Add a module to the execution engine. Ownership of the module is
+ transferred to the engine.
+ """
+
+ @property
+ def target_data(self):
+ """
+ The LLVM "target data" object for this codegen instance.
+ """
+ return self._target_data
+
+ def create_library(self, name, **kwargs):
+ """
+ Create a :class:`CodeLibrary` object for use with this codegen
+ instance.
+ """
+ return self._library_class(self, name, **kwargs)
+
+ def unserialize_library(self, serialized):
+ return self._library_class._unserialize(self, serialized)
+
+
+class CPUCodegen(Codegen):
+
+ def __init__(self, module_name):
+ initialize_llvm()
+
+ self._data_layout = None
+ self._llvm_module = ll.parse_assembly(
+ str(self._create_empty_module(module_name)))
+ self._llvm_module.name = "global_codegen_module"
+ self._rtlinker = RuntimeLinker()
+ self._init(self._llvm_module)
+
+ def _init(self, llvm_module):
+ assert list(llvm_module.global_variables) == [], "Module isn't empty"
+
+ target = ll.Target.from_triple(ll.get_process_triple())
+ tm_options = dict(opt=config.OPT)
+ self._tm_features = self._customize_tm_features()
+ self._customize_tm_options(tm_options)
+ tm = target.create_target_machine(**tm_options)
+ use_lmm = config.USE_LLVMLITE_MEMORY_MANAGER
+ engine = ll.create_mcjit_compiler(llvm_module, tm, use_lmm=use_lmm)
+
+ if config.ENABLE_PROFILING:
+ engine.enable_jit_events()
+
+ self._tm = tm
+ self._engine = JitEngine(engine)
+ self._target_data = engine.target_data
+ self._data_layout = str(self._target_data)
+
+ if config.OPT.is_opt_max:
+ # If the OPT level is set to 'max' then the user is requesting that
+ # compilation time is traded for potential performance gain. This
+ # currently manifests as running the "cheap" pass at -O3
+ # optimisation level with loop-vectorization enabled. There's no
+ # guarantee that this will increase runtime performance, it may
+ # detriment it, this is here to give the user an easily accessible
+ # option to try.
+ self._loopvect = True
+ self._opt_level = 3
+ else:
+ # The default behaviour is to do an opt=0 pass to try and inline as
+ # much as possible with the cheapest cost of doing so. This is so
+ # that the ref-op pruner pass that runs after the cheap pass will
+ # have the largest possible scope for working on pruning references.
+ self._loopvect = False
+ self._opt_level = 0
+
+ self._engine.set_object_cache(self._library_class._object_compiled_hook,
+ self._library_class._object_getbuffer_hook)
+
+ def _create_empty_module(self, name):
+ ir_module = llvmir.Module(cgutils.normalize_ir_text(name))
+ ir_module.triple = ll.get_process_triple()
+ if self._data_layout:
+ ir_module.data_layout = self._data_layout
+ return ir_module
+
+ def _module_pass_manager(self, **kwargs):
+ pm = ll.create_module_pass_manager()
+ pm.add_target_library_info(ll.get_process_triple())
+ self._tm.add_analysis_passes(pm)
+ cost = kwargs.pop("cost", None)
+ with self._pass_manager_builder(**kwargs) as pmb:
+ pmb.populate(pm)
+ # If config.OPT==0 do not include these extra passes to help with
+ # vectorization.
+ if cost is not None and cost == "cheap" and config.OPT != 0:
+ # This knocks loops into rotated form early to reduce the likelihood
+ # of vectorization failing due to unknown PHI nodes.
+ pm.add_loop_rotate_pass()
+ # These passes are required to get SVML to vectorize tests
+ pm.add_instruction_combining_pass()
+ pm.add_jump_threading_pass()
+
+ if config.LLVM_REFPRUNE_PASS:
+ pm.add_refprune_pass(_parse_refprune_flags())
+ return pm
+
+ def _function_pass_manager(self, llvm_module, **kwargs):
+ pm = ll.create_function_pass_manager(llvm_module)
+ pm.add_target_library_info(llvm_module.triple)
+ self._tm.add_analysis_passes(pm)
+ with self._pass_manager_builder(**kwargs) as pmb:
+ pmb.populate(pm)
+ if config.LLVM_REFPRUNE_PASS:
+ pm.add_refprune_pass(_parse_refprune_flags())
+ return pm
+
+ def _pass_manager_builder(self, **kwargs):
+ """
+ Create a PassManagerBuilder.
+
+ Note: a PassManagerBuilder seems good only for one use, so you
+ should call this method each time you want to populate a module
+ or function pass manager. Otherwise some optimizations will be
+ missed...
+ """
+ opt_level = kwargs.pop('opt', config.OPT)
+ loop_vectorize = kwargs.pop('loop_vectorize', config.LOOP_VECTORIZE)
+ slp_vectorize = kwargs.pop('slp_vectorize', config.SLP_VECTORIZE)
+
+ pmb = create_pass_manager_builder(opt=opt_level,
+ loop_vectorize=loop_vectorize,
+ slp_vectorize=slp_vectorize,
+ **kwargs)
+
+ return pmb
+
+ def _check_llvm_bugs(self):
+ """
+ Guard against some well-known LLVM bug(s).
+ """
+ # Check the locale bug at https://github.com/numba/numba/issues/1569
+ # Note we can't cache the result as locale settings can change
+ # across a process's lifetime. Also, for this same reason,
+ # the check here is a mere heuristic (there may be a race condition
+ # between now and actually compiling IR).
+ ir = """
+ define double @func()
+ {
+ ret double 1.23e+01
+ }
+ """
+ mod = ll.parse_assembly(ir)
+ ir_out = str(mod)
+ if "12.3" in ir_out or "1.23" in ir_out:
+ # Everything ok
+ return
+ if "1.0" in ir_out:
+ loc = locale.getlocale()
+ raise RuntimeError(
+ "LLVM will produce incorrect floating-point code "
+ "in the current locale %s.\nPlease read "
+ "https://numba.readthedocs.io/en/stable/user/faq.html#llvm-locale-bug "
+ "for more information."
+ % (loc,))
+ raise AssertionError("Unexpected IR:\n%s\n" % (ir_out,))
+
+ def magic_tuple(self):
+ """
+ Return a tuple unambiguously describing the codegen behaviour.
+ """
+ return (self._llvm_module.triple, self._get_host_cpu_name(),
+ self._tm_features)
+
+ def _scan_and_fix_unresolved_refs(self, module):
+ self._rtlinker.scan_unresolved_symbols(module, self._engine)
+ self._rtlinker.scan_defined_symbols(module)
+ self._rtlinker.resolve(self._engine)
+
+ def insert_unresolved_ref(self, builder, fnty, name):
+ voidptr = llvmir.IntType(8).as_pointer()
+ ptrname = self._rtlinker.PREFIX + name
+ llvm_mod = builder.module
+ try:
+ fnptr = llvm_mod.get_global(ptrname)
+ except KeyError:
+ # Not defined?
+ fnptr = llvmir.GlobalVariable(llvm_mod, voidptr, name=ptrname)
+ fnptr.linkage = 'external'
+ return builder.bitcast(builder.load(fnptr), fnty.as_pointer())
+
+ def _get_host_cpu_name(self):
+ return (ll.get_host_cpu_name()
+ if config.CPU_NAME is None
+ else config.CPU_NAME)
+
+ def _get_host_cpu_features(self):
+ if config.CPU_FEATURES is not None:
+ return config.CPU_FEATURES
+ return get_host_cpu_features()
+
+
+class AOTCPUCodegen(CPUCodegen):
+ """
+ A codegen implementation suitable for Ahead-Of-Time compilation
+ (e.g. generation of object files).
+ """
+
+ _library_class = AOTCodeLibrary
+
+ def __init__(self, module_name, cpu_name=None):
+ # By default, use generic cpu model for the arch
+ self._cpu_name = cpu_name or ''
+ CPUCodegen.__init__(self, module_name)
+
+ def _customize_tm_options(self, options):
+ cpu_name = self._cpu_name
+ if cpu_name == 'host':
+ cpu_name = self._get_host_cpu_name()
+ options['cpu'] = cpu_name
+ options['reloc'] = 'pic'
+ options['codemodel'] = 'default'
+ options['features'] = self._tm_features
+
+ def _customize_tm_features(self):
+ # ISA features are selected according to the requested CPU model
+ # in _customize_tm_options()
+ return ''
+
+ def _add_module(self, module):
+ pass
+
+
+class JITCPUCodegen(CPUCodegen):
+ """
+ A codegen implementation suitable for Just-In-Time compilation.
+ """
+
+ _library_class = JITCodeLibrary
+
+ def _customize_tm_options(self, options):
+ # As long as we don't want to ship the code to another machine,
+ # we can specialize for this CPU.
+ options['cpu'] = self._get_host_cpu_name()
+ # LLVM 7 change: # https://reviews.llvm.org/D47211#inline-425406
+ # JIT needs static relocation on x86*
+ # native target is already initialized from base class __init__
+ arch = ll.Target.from_default_triple().name
+ if arch.startswith('x86'): # one of x86 or x86_64
+ reloc_model = 'static'
+ elif arch.startswith('ppc'):
+ reloc_model = 'pic'
+ else:
+ reloc_model = 'default'
+ options['reloc'] = reloc_model
+ options['codemodel'] = 'jitdefault'
+
+ # Set feature attributes (such as ISA extensions)
+ # This overrides default feature selection by CPU model above
+ options['features'] = self._tm_features
+
+ # Deal with optional argument to ll.Target.create_target_machine
+ sig = utils.pysignature(ll.Target.create_target_machine)
+ if 'jit' in sig.parameters:
+ # Mark that this is making a JIT engine
+ options['jit'] = True
+
+ def _customize_tm_features(self):
+ # For JIT target, we will use LLVM to get the feature map
+ return self._get_host_cpu_features()
+
+ def _add_module(self, module):
+ self._engine.add_module(module)
+ # XXX: disabling remove module due to MCJIT engine leakage in
+ # removeModule. The removeModule causes consistent access
+ # violation with certain test combinations.
+ # # Early bind the engine method to avoid keeping a reference to self.
+ # return functools.partial(self._engine.remove_module, module)
+
+ def set_env(self, env_name, env):
+ """Set the environment address.
+
+ Update the GlobalVariable named *env_name* to the address of *env*.
+ """
+ gvaddr = self._engine.get_global_value_address(env_name)
+ envptr = (ctypes.c_void_p * 1).from_address(gvaddr)
+ envptr[0] = ctypes.c_void_p(id(env))
+
+
+def initialize_llvm():
+ """Safe to use multiple times.
+ """
+ ll.initialize()
+ ll.initialize_native_target()
+ ll.initialize_native_asmprinter()
+
+
+def get_host_cpu_features():
+ """Get host CPU features using LLVM.
+
+ The features may be modified due to user setting.
+ See numba.config.ENABLE_AVX.
+ """
+ try:
+ features = ll.get_host_cpu_features()
+ except RuntimeError:
+ return ''
+ else:
+ if not config.ENABLE_AVX:
+ # Disable all features with name starting with 'avx'
+ for k in features:
+ if k.startswith('avx'):
+ features[k] = False
+
+ # Set feature attributes
+ return features.flatten()
diff --git a/venv/lib/python3.10/site-packages/numba/core/compiler.py b/venv/lib/python3.10/site-packages/numba/core/compiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4259f555262dfd1170683835b4e0cdb74859f52
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/compiler.py
@@ -0,0 +1,813 @@
+from collections import namedtuple
+import copy
+import warnings
+from numba.core.tracing import event
+
+from numba.core import (errors, interpreter, bytecode, postproc, config,
+ callconv, cpu)
+from numba.parfors.parfor import ParforDiagnostics
+from numba.core.errors import CompilerError
+from numba.core.environment import lookup_environment
+
+from numba.core.compiler_machinery import PassManager
+
+from numba.core.untyped_passes import (ExtractByteCode, TranslateByteCode,
+ FixupArgs, IRProcessing, DeadBranchPrune,
+ RewriteSemanticConstants,
+ InlineClosureLikes, GenericRewrites,
+ WithLifting, InlineInlinables,
+ FindLiterallyCalls,
+ MakeFunctionToJitFunction,
+ CanonicalizeLoopExit,
+ CanonicalizeLoopEntry, LiteralUnroll,
+ ReconstructSSA, RewriteDynamicRaises,
+ LiteralPropagationSubPipelinePass,
+ )
+
+from numba.core.typed_passes import (NopythonTypeInference, AnnotateTypes,
+ NopythonRewrites, PreParforPass,
+ ParforPass, DumpParforDiagnostics,
+ IRLegalization, NoPythonBackend,
+ InlineOverloads, PreLowerStripPhis,
+ NativeLowering, NativeParforLowering,
+ NoPythonSupportedFeatureValidation,
+ ParforFusionPass, ParforPreLoweringPass
+ )
+
+from numba.core.object_mode_passes import (ObjectModeFrontEnd,
+ ObjectModeBackEnd)
+from numba.core.targetconfig import TargetConfig, Option, ConfigStack
+
+
+class Flags(TargetConfig):
+ __slots__ = ()
+
+ enable_looplift = Option(
+ type=bool,
+ default=False,
+ doc="Enable loop-lifting",
+ )
+ enable_pyobject = Option(
+ type=bool,
+ default=False,
+ doc="Enable pyobject mode (in general)",
+ )
+ enable_pyobject_looplift = Option(
+ type=bool,
+ default=False,
+ doc="Enable pyobject mode inside lifted loops",
+ )
+ enable_ssa = Option(
+ type=bool,
+ default=True,
+ doc="Enable SSA",
+ )
+ force_pyobject = Option(
+ type=bool,
+ default=False,
+ doc="Force pyobject mode inside the whole function",
+ )
+ release_gil = Option(
+ type=bool,
+ default=False,
+ doc="Release GIL inside the native function",
+ )
+ no_compile = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ debuginfo = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ boundscheck = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ forceinline = Option(
+ type=bool,
+ default=False,
+ doc="Force inlining of the function. Overrides _dbg_optnone.",
+ )
+ no_cpython_wrapper = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ no_cfunc_wrapper = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ auto_parallel = Option(
+ type=cpu.ParallelOptions,
+ default=cpu.ParallelOptions(False),
+ doc="""Enable automatic parallel optimization, can be fine-tuned by
+taking a dictionary of sub-options instead of a boolean, see parfor.py for
+detail""",
+ )
+ nrt = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ no_rewrites = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ error_model = Option(
+ type=str,
+ default="python",
+ doc="TODO",
+ )
+ fastmath = Option(
+ type=cpu.FastMathOptions,
+ default=cpu.FastMathOptions(False),
+ doc="TODO",
+ )
+ noalias = Option(
+ type=bool,
+ default=False,
+ doc="TODO",
+ )
+ inline = Option(
+ type=cpu.InlineOptions,
+ default=cpu.InlineOptions("never"),
+ doc="TODO",
+ )
+
+ dbg_extend_lifetimes = Option(
+ type=bool,
+ default=False,
+ doc=("Extend variable lifetime for debugging. "
+ "This automatically turns on with debug=True."),
+ )
+
+ dbg_optnone = Option(
+ type=bool,
+ default=False,
+ doc=("Disable optimization for debug. "
+ "Equivalent to adding optnone attribute in the LLVM Function.")
+ )
+
+ dbg_directives_only = Option(
+ type=bool,
+ default=False,
+ doc=("Make debug emissions directives-only. "
+ "Used when generating lineinfo.")
+ )
+
+
+DEFAULT_FLAGS = Flags()
+DEFAULT_FLAGS.nrt = True
+
+
+CR_FIELDS = ["typing_context",
+ "target_context",
+ "entry_point",
+ "typing_error",
+ "type_annotation",
+ "signature",
+ "objectmode",
+ "lifted",
+ "fndesc",
+ "library",
+ "call_helper",
+ "environment",
+ "metadata",
+ # List of functions to call to initialize on unserialization
+ # (i.e cache load).
+ "reload_init",
+ "referenced_envs",
+ ]
+
+
+class CompileResult(namedtuple("_CompileResult", CR_FIELDS)):
+ """
+ A structure holding results from the compilation of a function.
+ """
+
+ __slots__ = ()
+
+ def _reduce(self):
+ """
+ Reduce a CompileResult to picklable components.
+ """
+ libdata = self.library.serialize_using_object_code()
+ # Make it (un)picklable efficiently
+ typeann = str(self.type_annotation)
+ fndesc = self.fndesc
+ # Those don't need to be pickled and may fail
+ fndesc.typemap = fndesc.calltypes = None
+ # Include all referenced environments
+ referenced_envs = self._find_referenced_environments()
+ return (libdata, self.fndesc, self.environment, self.signature,
+ self.objectmode, self.lifted, typeann, self.reload_init,
+ tuple(referenced_envs))
+
+ def _find_referenced_environments(self):
+ """Returns a list of referenced environments
+ """
+ mod = self.library._final_module
+ # Find environments
+ referenced_envs = []
+ for gv in mod.global_variables:
+ gvn = gv.name
+ if gvn.startswith("_ZN08NumbaEnv"):
+ env = lookup_environment(gvn)
+ if env is not None:
+ if env.can_cache():
+ referenced_envs.append(env)
+ return referenced_envs
+
+ @classmethod
+ def _rebuild(cls, target_context, libdata, fndesc, env,
+ signature, objectmode, lifted, typeann,
+ reload_init, referenced_envs):
+ if reload_init:
+ # Re-run all
+ for fn in reload_init:
+ fn()
+
+ library = target_context.codegen().unserialize_library(libdata)
+ cfunc = target_context.get_executable(library, fndesc, env)
+ cr = cls(target_context=target_context,
+ typing_context=target_context.typing_context,
+ library=library,
+ environment=env,
+ entry_point=cfunc,
+ fndesc=fndesc,
+ type_annotation=typeann,
+ signature=signature,
+ objectmode=objectmode,
+ lifted=lifted,
+ typing_error=None,
+ call_helper=None,
+ metadata=None, # Do not store, arbitrary & potentially large!
+ reload_init=reload_init,
+ referenced_envs=referenced_envs,
+ )
+
+ # Load Environments
+ for env in referenced_envs:
+ library.codegen.set_env(env.env_name, env)
+
+ return cr
+
+ @property
+ def codegen(self):
+ return self.target_context.codegen()
+
+ def dump(self, tab=''):
+ print(f'{tab}DUMP {type(self).__name__} {self.entry_point}')
+ self.signature.dump(tab=tab + ' ')
+ print(f'{tab}END DUMP')
+
+
+_LowerResult = namedtuple("_LowerResult", [
+ "fndesc",
+ "call_helper",
+ "cfunc",
+ "env",
+])
+
+
+def sanitize_compile_result_entries(entries):
+ keys = set(entries.keys())
+ fieldset = set(CR_FIELDS)
+ badnames = keys - fieldset
+ if badnames:
+ raise NameError(*badnames)
+ missing = fieldset - keys
+ for k in missing:
+ entries[k] = None
+ # Avoid keeping alive traceback variables
+ err = entries['typing_error']
+ if err is not None:
+ entries['typing_error'] = err.with_traceback(None)
+ return entries
+
+
+def compile_result(**entries):
+ entries = sanitize_compile_result_entries(entries)
+ return CompileResult(**entries)
+
+
+def run_frontend(func, inline_closures=False, emit_dels=False):
+ """
+ Run the compiler frontend over the given Python function, and return
+ the function's canonical Numba IR.
+
+ If inline_closures is Truthy then closure inlining will be run
+ If emit_dels is Truthy the ir.Del nodes will be emitted appropriately
+ """
+ # XXX make this a dedicated Pipeline?
+ func_id = bytecode.FunctionIdentity.from_function(func)
+ interp = interpreter.Interpreter(func_id)
+ bc = bytecode.ByteCode(func_id=func_id)
+ func_ir = interp.interpret(bc)
+ if inline_closures:
+ from numba.core.inline_closurecall import InlineClosureCallPass
+ inline_pass = InlineClosureCallPass(func_ir, cpu.ParallelOptions(False),
+ {}, False)
+ inline_pass.run()
+ post_proc = postproc.PostProcessor(func_ir)
+ post_proc.run(emit_dels)
+ return func_ir
+
+
+class _CompileStatus(object):
+ """
+ Describes the state of compilation. Used like a C record.
+ """
+ __slots__ = ['fail_reason', 'can_fallback']
+
+ def __init__(self, can_fallback):
+ self.fail_reason = None
+ self.can_fallback = can_fallback
+
+ def __repr__(self):
+ vals = []
+ for k in self.__slots__:
+ vals.append("{k}={v}".format(k=k, v=getattr(self, k)))
+ return ', '.join(vals)
+
+
+class _EarlyPipelineCompletion(Exception):
+ """
+ Raised to indicate that a pipeline has completed early
+ """
+
+ def __init__(self, result):
+ self.result = result
+
+
+class StateDict(dict):
+ """
+ A dictionary that has an overloaded getattr and setattr to permit getting
+ and setting key/values through the use of attributes.
+ """
+
+ def __getattr__(self, attr):
+ try:
+ return self[attr]
+ except KeyError:
+ raise AttributeError(attr)
+
+ def __setattr__(self, attr, value):
+ self[attr] = value
+
+
+def _make_subtarget(targetctx, flags):
+ """
+ Make a new target context from the given target context and flags.
+ """
+ subtargetoptions = {}
+ if flags.debuginfo:
+ subtargetoptions['enable_debuginfo'] = True
+ if flags.boundscheck:
+ subtargetoptions['enable_boundscheck'] = True
+ if flags.nrt:
+ subtargetoptions['enable_nrt'] = True
+ if flags.auto_parallel:
+ subtargetoptions['auto_parallel'] = flags.auto_parallel
+ if flags.fastmath:
+ subtargetoptions['fastmath'] = flags.fastmath
+ error_model = callconv.create_error_model(flags.error_model, targetctx)
+ subtargetoptions['error_model'] = error_model
+
+ return targetctx.subtarget(**subtargetoptions)
+
+
+class CompilerBase(object):
+ """
+ Stores and manages states for the compiler
+ """
+
+ def __init__(self, typingctx, targetctx, library, args, return_type, flags,
+ locals):
+ # Make sure the environment is reloaded
+ config.reload_config()
+ typingctx.refresh()
+ targetctx.refresh()
+
+ self.state = StateDict()
+
+ self.state.typingctx = typingctx
+ self.state.targetctx = _make_subtarget(targetctx, flags)
+ self.state.library = library
+ self.state.args = args
+ self.state.return_type = return_type
+ self.state.flags = flags
+ self.state.locals = locals
+
+ # Results of various steps of the compilation pipeline
+ self.state.bc = None
+ self.state.func_id = None
+ self.state.func_ir = None
+ self.state.lifted = None
+ self.state.lifted_from = None
+ self.state.typemap = None
+ self.state.calltypes = None
+ self.state.type_annotation = None
+ # holds arbitrary inter-pipeline stage meta data
+ self.state.metadata = {}
+ self.state.reload_init = []
+ # hold this for e.g. with_lifting, null out on exit
+ self.state.pipeline = self
+
+ # parfor diagnostics info, add to metadata
+ self.state.parfor_diagnostics = ParforDiagnostics()
+ self.state.metadata['parfor_diagnostics'] = \
+ self.state.parfor_diagnostics
+ self.state.metadata['parfors'] = {}
+
+ self.state.status = _CompileStatus(
+ can_fallback=self.state.flags.enable_pyobject
+ )
+
+ def compile_extra(self, func):
+ self.state.func_id = bytecode.FunctionIdentity.from_function(func)
+ ExtractByteCode().run_pass(self.state)
+
+ self.state.lifted = ()
+ self.state.lifted_from = None
+ return self._compile_bytecode()
+
+ def compile_ir(self, func_ir, lifted=(), lifted_from=None):
+ self.state.func_id = func_ir.func_id
+ self.state.lifted = lifted
+ self.state.lifted_from = lifted_from
+ self.state.func_ir = func_ir
+ self.state.nargs = self.state.func_ir.arg_count
+
+ FixupArgs().run_pass(self.state)
+ return self._compile_ir()
+
+ def define_pipelines(self):
+ """Child classes override this to customize the pipelines in use.
+ """
+ raise NotImplementedError()
+
+ def _compile_core(self):
+ """
+ Populate and run compiler pipeline
+ """
+ with ConfigStack().enter(self.state.flags.copy()):
+ pms = self.define_pipelines()
+ for pm in pms:
+ pipeline_name = pm.pipeline_name
+ func_name = "%s.%s" % (self.state.func_id.modname,
+ self.state.func_id.func_qualname)
+
+ event("Pipeline: %s for %s" % (pipeline_name, func_name))
+ self.state.metadata['pipeline_times'] = {pipeline_name:
+ pm.exec_times}
+ is_final_pipeline = pm == pms[-1]
+ res = None
+ try:
+ pm.run(self.state)
+ if self.state.cr is not None:
+ break
+ except _EarlyPipelineCompletion as e:
+ res = e.result
+ break
+ except Exception as e:
+ if not isinstance(e, errors.NumbaError):
+ raise e
+ self.state.status.fail_reason = e
+ if is_final_pipeline:
+ raise e
+ else:
+ raise CompilerError("All available pipelines exhausted")
+
+ # Pipeline is done, remove self reference to release refs to user
+ # code
+ self.state.pipeline = None
+
+ # organise a return
+ if res is not None:
+ # Early pipeline completion
+ return res
+ else:
+ assert self.state.cr is not None
+ return self.state.cr
+
+ def _compile_bytecode(self):
+ """
+ Populate and run pipeline for bytecode input
+ """
+ assert self.state.func_ir is None
+ return self._compile_core()
+
+ def _compile_ir(self):
+ """
+ Populate and run pipeline for IR input
+ """
+ assert self.state.func_ir is not None
+ return self._compile_core()
+
+
+class Compiler(CompilerBase):
+ """The default compiler
+ """
+
+ def define_pipelines(self):
+ if self.state.flags.force_pyobject:
+ # either object mode
+ return [DefaultPassBuilder.define_objectmode_pipeline(self.state),]
+ else:
+ # or nopython mode
+ return [DefaultPassBuilder.define_nopython_pipeline(self.state),]
+
+
+class DefaultPassBuilder(object):
+ """
+ This is the default pass builder, it contains the "classic" default
+ pipelines as pre-canned PassManager instances:
+ - nopython
+ - objectmode
+ - interpreted
+ - typed
+ - untyped
+ - nopython lowering
+ """
+ @staticmethod
+ def define_nopython_pipeline(state, name='nopython'):
+ """Returns an nopython mode pipeline based PassManager
+ """
+ # compose pipeline from untyped, typed and lowering parts
+ dpb = DefaultPassBuilder
+ pm = PassManager(name)
+ untyped_passes = dpb.define_untyped_pipeline(state)
+ pm.passes.extend(untyped_passes.passes)
+
+ typed_passes = dpb.define_typed_pipeline(state)
+ pm.passes.extend(typed_passes.passes)
+
+ lowering_passes = dpb.define_nopython_lowering_pipeline(state)
+ pm.passes.extend(lowering_passes.passes)
+
+ pm.finalize()
+ return pm
+
+ @staticmethod
+ def define_nopython_lowering_pipeline(state, name='nopython_lowering'):
+ pm = PassManager(name)
+ # legalise
+ pm.add_pass(NoPythonSupportedFeatureValidation,
+ "ensure features that are in use are in a valid form")
+ pm.add_pass(IRLegalization,
+ "ensure IR is legal prior to lowering")
+ # Annotate only once legalized
+ pm.add_pass(AnnotateTypes, "annotate types")
+ # lower
+ if state.flags.auto_parallel.enabled:
+ pm.add_pass(NativeParforLowering, "native parfor lowering")
+ else:
+ pm.add_pass(NativeLowering, "native lowering")
+ pm.add_pass(NoPythonBackend, "nopython mode backend")
+ pm.add_pass(DumpParforDiagnostics, "dump parfor diagnostics")
+ pm.finalize()
+ return pm
+
+ @staticmethod
+ def define_parfor_gufunc_nopython_lowering_pipeline(
+ state, name='parfor_gufunc_nopython_lowering'):
+ pm = PassManager(name)
+ # legalise
+ pm.add_pass(NoPythonSupportedFeatureValidation,
+ "ensure features that are in use are in a valid form")
+ pm.add_pass(IRLegalization,
+ "ensure IR is legal prior to lowering")
+ # Annotate only once legalized
+ pm.add_pass(AnnotateTypes, "annotate types")
+ # lower
+ if state.flags.auto_parallel.enabled:
+ pm.add_pass(NativeParforLowering, "native parfor lowering")
+ else:
+ pm.add_pass(NativeLowering, "native lowering")
+ pm.add_pass(NoPythonBackend, "nopython mode backend")
+ pm.finalize()
+ return pm
+
+ @staticmethod
+ def define_typed_pipeline(state, name="typed"):
+ """Returns the typed part of the nopython pipeline"""
+ pm = PassManager(name)
+ # typing
+ pm.add_pass(NopythonTypeInference, "nopython frontend")
+
+ # strip phis
+ pm.add_pass(PreLowerStripPhis, "remove phis nodes")
+
+ # optimisation
+ pm.add_pass(InlineOverloads, "inline overloaded functions")
+ if state.flags.auto_parallel.enabled:
+ pm.add_pass(PreParforPass, "Preprocessing for parfors")
+ if not state.flags.no_rewrites:
+ pm.add_pass(NopythonRewrites, "nopython rewrites")
+ if state.flags.auto_parallel.enabled:
+ pm.add_pass(ParforPass, "convert to parfors")
+ pm.add_pass(ParforFusionPass, "fuse parfors")
+ pm.add_pass(ParforPreLoweringPass, "parfor prelowering")
+
+ pm.finalize()
+ return pm
+
+ @staticmethod
+ def define_parfor_gufunc_pipeline(state, name="parfor_gufunc_typed"):
+ """Returns the typed part of the nopython pipeline"""
+ pm = PassManager(name)
+ assert state.func_ir
+ pm.add_pass(IRProcessing, "processing IR")
+ pm.add_pass(NopythonTypeInference, "nopython frontend")
+ pm.add_pass(ParforPreLoweringPass, "parfor prelowering")
+
+ pm.finalize()
+ return pm
+
+ @staticmethod
+ def define_untyped_pipeline(state, name='untyped'):
+ """Returns an untyped part of the nopython pipeline"""
+ pm = PassManager(name)
+ if state.func_ir is None:
+ pm.add_pass(TranslateByteCode, "analyzing bytecode")
+ pm.add_pass(FixupArgs, "fix up args")
+ pm.add_pass(IRProcessing, "processing IR")
+ pm.add_pass(WithLifting, "Handle with contexts")
+
+ # inline closures early in case they are using nonlocal's
+ # see issue #6585.
+ pm.add_pass(InlineClosureLikes,
+ "inline calls to locally defined closures")
+
+ # pre typing
+ if not state.flags.no_rewrites:
+ pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants")
+ pm.add_pass(DeadBranchPrune, "dead branch pruning")
+ pm.add_pass(GenericRewrites, "nopython rewrites")
+
+ pm.add_pass(RewriteDynamicRaises, "rewrite dynamic raises")
+
+ # convert any remaining closures into functions
+ pm.add_pass(MakeFunctionToJitFunction,
+ "convert make_function into JIT functions")
+ # inline functions that have been determined as inlinable and rerun
+ # branch pruning, this needs to be run after closures are inlined as
+ # the IR repr of a closure masks call sites if an inlinable is called
+ # inside a closure
+ pm.add_pass(InlineInlinables, "inline inlinable functions")
+ if not state.flags.no_rewrites:
+ pm.add_pass(DeadBranchPrune, "dead branch pruning")
+
+ pm.add_pass(FindLiterallyCalls, "find literally calls")
+ pm.add_pass(LiteralUnroll, "handles literal_unroll")
+
+ if state.flags.enable_ssa:
+ pm.add_pass(ReconstructSSA, "ssa")
+
+ if not state.flags.no_rewrites:
+ pm.add_pass(DeadBranchPrune, "dead branch pruning")
+
+ pm.add_pass(LiteralPropagationSubPipelinePass, "Literal propagation")
+
+ pm.finalize()
+ return pm
+
+ @staticmethod
+ def define_objectmode_pipeline(state, name='object'):
+ """Returns an object-mode pipeline based PassManager
+ """
+ pm = PassManager(name)
+ if state.func_ir is None:
+ pm.add_pass(TranslateByteCode, "analyzing bytecode")
+ pm.add_pass(FixupArgs, "fix up args")
+ else:
+ # Reaches here if it's a fallback from nopython mode.
+ # Strip the phi nodes.
+ pm.add_pass(PreLowerStripPhis, "remove phis nodes")
+ pm.add_pass(IRProcessing, "processing IR")
+
+ # The following passes are needed to adjust for looplifting
+ pm.add_pass(CanonicalizeLoopEntry, "canonicalize loop entry")
+ pm.add_pass(CanonicalizeLoopExit, "canonicalize loop exit")
+
+ pm.add_pass(ObjectModeFrontEnd, "object mode frontend")
+ pm.add_pass(InlineClosureLikes,
+ "inline calls to locally defined closures")
+ # convert any remaining closures into functions
+ pm.add_pass(MakeFunctionToJitFunction,
+ "convert make_function into JIT functions")
+ pm.add_pass(IRLegalization, "ensure IR is legal prior to lowering")
+ pm.add_pass(AnnotateTypes, "annotate types")
+ pm.add_pass(ObjectModeBackEnd, "object mode backend")
+ pm.finalize()
+ return pm
+
+
+def compile_extra(typingctx, targetctx, func, args, return_type, flags,
+ locals, library=None, pipeline_class=Compiler):
+ """Compiler entry point
+
+ Parameter
+ ---------
+ typingctx :
+ typing context
+ targetctx :
+ target context
+ func : function
+ the python function to be compiled
+ args : tuple, list
+ argument types
+ return_type :
+ Use ``None`` to indicate void return
+ flags : numba.compiler.Flags
+ compiler flags
+ library : numba.codegen.CodeLibrary
+ Used to store the compiled code.
+ If it is ``None``, a new CodeLibrary is used.
+ pipeline_class : type like numba.compiler.CompilerBase
+ compiler pipeline
+ """
+ pipeline = pipeline_class(typingctx, targetctx, library,
+ args, return_type, flags, locals)
+ return pipeline.compile_extra(func)
+
+
+def compile_ir(typingctx, targetctx, func_ir, args, return_type, flags,
+ locals, lifted=(), lifted_from=None, is_lifted_loop=False,
+ library=None, pipeline_class=Compiler):
+ """
+ Compile a function with the given IR.
+
+ For internal use only.
+ """
+
+ # This is a special branch that should only run on IR from a lifted loop
+ if is_lifted_loop:
+ # This code is pessimistic and costly, but it is a not often trodden
+ # path and it will go away once IR is made immutable. The problem is
+ # that the rewrite passes can mutate the IR into a state that makes
+ # it possible for invalid tokens to be transmitted to lowering which
+ # then trickle through into LLVM IR and causes RuntimeErrors as LLVM
+ # cannot compile it. As a result the following approach is taken:
+ # 1. Create some new flags that copy the original ones but switch
+ # off rewrites.
+ # 2. Compile with 1. to get a compile result
+ # 3. Try and compile another compile result but this time with the
+ # original flags (and IR being rewritten).
+ # 4. If 3 was successful, use the result, else use 2.
+
+ # create flags with no rewrites
+ norw_flags = copy.deepcopy(flags)
+ norw_flags.no_rewrites = True
+
+ def compile_local(the_ir, the_flags):
+ pipeline = pipeline_class(typingctx, targetctx, library,
+ args, return_type, the_flags, locals)
+ return pipeline.compile_ir(func_ir=the_ir, lifted=lifted,
+ lifted_from=lifted_from)
+
+ # compile with rewrites off, IR shouldn't be mutated irreparably
+ norw_cres = compile_local(func_ir.copy(), norw_flags)
+
+ # try and compile with rewrites on if no_rewrites was not set in the
+ # original flags, IR might get broken but we've got a CompileResult
+ # that's usable from above.
+ rw_cres = None
+ if not flags.no_rewrites:
+ # Suppress warnings in compilation retry
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore", errors.NumbaWarning)
+ try:
+ rw_cres = compile_local(func_ir.copy(), flags)
+ except Exception:
+ pass
+ # if the rewrite variant of compilation worked, use it, else use
+ # the norewrites backup
+ if rw_cres is not None:
+ cres = rw_cres
+ else:
+ cres = norw_cres
+ return cres
+
+ else:
+ pipeline = pipeline_class(typingctx, targetctx, library,
+ args, return_type, flags, locals)
+ return pipeline.compile_ir(func_ir=func_ir, lifted=lifted,
+ lifted_from=lifted_from)
+
+
+def compile_internal(typingctx, targetctx, library,
+ func, args, return_type, flags, locals):
+ """
+ For internal use only.
+ """
+ pipeline = Compiler(typingctx, targetctx, library,
+ args, return_type, flags, locals)
+ return pipeline.compile_extra(func)
diff --git a/venv/lib/python3.10/site-packages/numba/core/compiler_lock.py b/venv/lib/python3.10/site-packages/numba/core/compiler_lock.py
new file mode 100644
index 0000000000000000000000000000000000000000..874fced9fd9924d549655b55caec96d7518182f4
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/compiler_lock.py
@@ -0,0 +1,56 @@
+import threading
+import functools
+import numba.core.event as ev
+
+
+# Lock for the preventing multiple compiler execution
+class _CompilerLock(object):
+ def __init__(self):
+ self._lock = threading.RLock()
+
+ def acquire(self):
+ ev.start_event("numba:compiler_lock")
+ self._lock.acquire()
+
+ def release(self):
+ self._lock.release()
+ ev.end_event("numba:compiler_lock")
+
+ def __enter__(self):
+ self.acquire()
+
+ def __exit__(self, exc_val, exc_type, traceback):
+ self.release()
+
+ def is_locked(self):
+ is_owned = getattr(self._lock, '_is_owned')
+ if not callable(is_owned):
+ is_owned = self._is_owned
+ return is_owned()
+
+ def __call__(self, func):
+ @functools.wraps(func)
+ def _acquire_compile_lock(*args, **kwargs):
+ with self:
+ return func(*args, **kwargs)
+ return _acquire_compile_lock
+
+ def _is_owned(self):
+ # This method is borrowed from threading.Condition.
+ # Return True if lock is owned by current_thread.
+ # This method is called only if _lock doesn't have _is_owned().
+ if self._lock.acquire(0):
+ self._lock.release()
+ return False
+ else:
+ return True
+
+
+global_compiler_lock = _CompilerLock()
+
+
+def require_global_compiler_lock():
+ """Sentry that checks the global_compiler_lock is acquired.
+ """
+ # Use assert to allow turning off this check
+ assert global_compiler_lock.is_locked()
diff --git a/venv/lib/python3.10/site-packages/numba/core/compiler_machinery.py b/venv/lib/python3.10/site-packages/numba/core/compiler_machinery.py
new file mode 100644
index 0000000000000000000000000000000000000000..a168264d3a4196a24f0e6571646c40c67427962f
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/compiler_machinery.py
@@ -0,0 +1,462 @@
+import timeit
+from abc import abstractmethod, ABCMeta
+from collections import namedtuple, OrderedDict
+import inspect
+
+
+from numba.core.compiler_lock import global_compiler_lock
+from numba.core import errors, config, transforms, utils
+from numba.core.tracing import event
+from numba.core.postproc import PostProcessor
+from numba.core.ir_utils import enforce_no_dels, legalize_single_scope
+import numba.core.event as ev
+
+# terminal color markup
+_termcolor = errors.termcolor()
+
+
+class SimpleTimer(object):
+ """
+ A simple context managed timer
+ """
+
+ def __enter__(self):
+ self.ts = timeit.default_timer()
+ return self
+
+ def __exit__(self, *exc):
+ self.elapsed = timeit.default_timer() - self.ts
+
+
+class CompilerPass(metaclass=ABCMeta):
+ """ The base class for all compiler passes.
+ """
+
+ @abstractmethod
+ def __init__(self, *args, **kwargs):
+ self._analysis = None
+ self._pass_id = None
+
+ @classmethod
+ def name(cls):
+ """
+ Returns the name of the pass
+ """
+ return cls._name
+
+ @property
+ def pass_id(self):
+ """
+ The ID of the pass
+ """
+ return self._pass_id
+
+ @pass_id.setter
+ def pass_id(self, val):
+ """
+ Sets the ID of the pass
+ """
+ self._pass_id = val
+
+ @property
+ def analysis(self):
+ """
+ Analysis data for the pass
+ """
+ return self._analysis
+
+ @analysis.setter
+ def analysis(self, val):
+ """
+ Set the analysis data for the pass
+ """
+ self._analysis = val
+
+ def run_initialization(self, *args, **kwargs):
+ """
+ Runs the initialization sequence for the pass, will run before
+ `run_pass`.
+ """
+ return False
+
+ @abstractmethod
+ def run_pass(self, *args, **kwargs):
+ """
+ Runs the pass itself. Must return True/False depending on whether
+ statement level modification took place.
+ """
+ pass
+
+ def run_finalizer(self, *args, **kwargs):
+ """
+ Runs the initialization sequence for the pass, will run before
+ `run_pass`.
+ """
+ return False
+
+ def get_analysis_usage(self, AU):
+ """ Override to set analysis usage
+ """
+ pass
+
+ def get_analysis(self, pass_name):
+ """
+ Gets the analysis from a given pass
+ """
+ return self._analysis[pass_name]
+
+
+class SSACompliantMixin(object):
+ """ Mixin to indicate a pass is SSA form compliant. Nothing is asserted
+ about this condition at present.
+ """
+ pass
+
+
+class FunctionPass(CompilerPass):
+ """ Base class for function passes
+ """
+ pass
+
+
+class AnalysisPass(CompilerPass):
+ """ Base class for analysis passes (no modification made to state)
+ """
+ pass
+
+
+class LoweringPass(CompilerPass):
+ """ Base class for lowering passes
+ """
+ pass
+
+
+class AnalysisUsage(object):
+ """This looks and behaves like LLVM's AnalysisUsage because its like that.
+ """
+
+ def __init__(self):
+ self._required = set()
+ self._preserved = set()
+
+ def get_required_set(self):
+ return self._required
+
+ def get_preserved_set(self):
+ return self._preserved
+
+ def add_required(self, pss):
+ self._required.add(pss)
+
+ def add_preserved(self, pss):
+ self._preserved.add(pss)
+
+ def __str__(self):
+ return "required: %s\n" % self._required
+
+
+_DEBUG = False
+
+
+def debug_print(*args, **kwargs):
+ if _DEBUG:
+ print(*args, **kwargs)
+
+
+pass_timings = namedtuple('pass_timings', 'init run finalize')
+
+
+class PassManager(object):
+ """
+ The PassManager is a named instance of a particular compilation pipeline
+ """
+ # TODO: Eventually enable this, it enforces self consistency after each pass
+ _ENFORCING = False
+
+ def __init__(self, pipeline_name):
+ """
+ Create a new pipeline with name "pipeline_name"
+ """
+ self.passes = []
+ self.exec_times = OrderedDict()
+ self._finalized = False
+ self._analysis = None
+ self._print_after = None
+ self.pipeline_name = pipeline_name
+
+ def _validate_pass(self, pass_cls):
+ if (not (isinstance(pass_cls, str) or
+ (inspect.isclass(pass_cls) and
+ issubclass(pass_cls, CompilerPass)))):
+ msg = ("Pass must be referenced by name or be a subclass of a "
+ "CompilerPass. Have %s" % pass_cls)
+ raise TypeError(msg)
+ if isinstance(pass_cls, str):
+ pass_cls = _pass_registry.find_by_name(pass_cls)
+ else:
+ if not _pass_registry.is_registered(pass_cls):
+ raise ValueError("Pass %s is not registered" % pass_cls)
+
+ def add_pass(self, pss, description=""):
+ """
+ Append a pass to the PassManager's compilation pipeline
+ """
+ self._validate_pass(pss)
+ func_desc_tuple = (pss, description)
+ self.passes.append(func_desc_tuple)
+ self._finalized = False
+
+ def add_pass_after(self, pass_cls, location):
+ """
+ Add a pass `pass_cls` to the PassManager's compilation pipeline after
+ the pass `location`.
+ """
+ assert self.passes
+ self._validate_pass(pass_cls)
+ self._validate_pass(location)
+ for idx, (x, _) in enumerate(self.passes):
+ if x == location:
+ break
+ else:
+ raise ValueError("Could not find pass %s" % location)
+ self.passes.insert(idx + 1, (pass_cls, str(pass_cls)))
+ # if a pass has been added, it's not finalized
+ self._finalized = False
+
+ def _debug_init(self):
+ # determine after which passes IR dumps should take place
+ def parse(conf_item):
+ print_passes = []
+ if conf_item != "none":
+ if conf_item == "all":
+ print_passes = [x.name() for (x, _) in self.passes]
+ else:
+ # we don't validate whether the named passes exist in this
+ # pipeline the compiler may be used reentrantly and
+ # different pipelines may contain different passes
+ splitted = conf_item.split(',')
+ print_passes = [x.strip() for x in splitted]
+ return print_passes
+ ret = (parse(config.DEBUG_PRINT_AFTER),
+ parse(config.DEBUG_PRINT_BEFORE),
+ parse(config.DEBUG_PRINT_WRAP),)
+ return ret
+
+ def finalize(self):
+ """
+ Finalize the PassManager, after which no more passes may be added
+ without re-finalization.
+ """
+ self._analysis = self.dependency_analysis()
+ self._print_after, self._print_before, self._print_wrap = \
+ self._debug_init()
+ self._finalized = True
+
+ @property
+ def finalized(self):
+ return self._finalized
+
+ def _patch_error(self, desc, exc):
+ """
+ Patches the error to show the stage that it arose in.
+ """
+ newmsg = "{desc}\n{exc}".format(desc=desc, exc=exc)
+ exc.args = (newmsg,)
+ return exc
+
+ @global_compiler_lock # this need a lock, likely calls LLVM
+ def _runPass(self, index, pss, internal_state):
+ mutated = False
+
+ def check(func, compiler_state):
+ mangled = func(compiler_state)
+ if mangled not in (True, False):
+ msg = ("CompilerPass implementations should return True/False. "
+ "CompilerPass with name '%s' did not.")
+ raise ValueError(msg % pss.name())
+ return mangled
+
+ def debug_print(pass_name, print_condition, printable_condition):
+ if pass_name in print_condition:
+ fid = internal_state.func_id
+ args = (fid.modname, fid.func_qualname, self.pipeline_name,
+ printable_condition, pass_name)
+ print(("%s.%s: %s: %s %s" % args).center(120, '-'))
+ if internal_state.func_ir is not None:
+ internal_state.func_ir.dump()
+ else:
+ print("func_ir is None")
+
+ # debug print before this pass?
+ debug_print(pss.name(), self._print_before + self._print_wrap, "BEFORE")
+
+ # wire in the analysis info so it's accessible
+ pss.analysis = self._analysis
+
+ qualname = internal_state.func_id.func_qualname
+
+ ev_details = dict(
+ name=f"{pss.name()} [{qualname}]",
+ qualname=qualname,
+ module=internal_state.func_id.modname,
+ flags=utils._lazy_pformat(internal_state.flags.values()),
+ args=str(internal_state.args),
+ return_type=str(internal_state.return_type),
+ )
+ errctx = errors.new_error_context(f"Pass {pss.name()}")
+ with ev.trigger_event("numba:run_pass", data=ev_details), errctx:
+ with SimpleTimer() as init_time:
+ mutated |= check(pss.run_initialization, internal_state)
+ with SimpleTimer() as pass_time:
+ mutated |= check(pss.run_pass, internal_state)
+ with SimpleTimer() as finalize_time:
+ mutated |= check(pss.run_finalizer, internal_state)
+
+ # Check that if the pass is an instance of a FunctionPass that it hasn't
+ # emitted ir.Dels.
+ if isinstance(pss, FunctionPass):
+ enforce_no_dels(internal_state.func_ir)
+
+ if self._ENFORCING:
+ # TODO: Add in self consistency enforcement for
+ # `func_ir._definitions` etc
+ if _pass_registry.get(pss.__class__).mutates_CFG:
+ if mutated: # block level changes, rebuild all
+ PostProcessor(internal_state.func_ir).run()
+ else: # CFG level changes rebuild CFG
+ internal_state.func_ir.blocks = transforms.canonicalize_cfg(
+ internal_state.func_ir.blocks)
+ # Check the func_ir has exactly one Scope instance
+ if not legalize_single_scope(internal_state.func_ir.blocks):
+ raise errors.CompilerError(
+ f"multiple scope in func_ir detected in {pss}",
+ )
+ # inject runtimes
+ pt = pass_timings(init_time.elapsed, pass_time.elapsed,
+ finalize_time.elapsed)
+ self.exec_times["%s_%s" % (index, pss.name())] = pt
+
+ # debug print after this pass?
+ debug_print(pss.name(), self._print_after + self._print_wrap, "AFTER")
+
+ def run(self, state):
+ """
+ Run the defined pipelines on the state.
+ """
+ from numba.core.compiler import _EarlyPipelineCompletion
+ if not self.finalized:
+ raise RuntimeError("Cannot run non-finalised pipeline")
+
+ # walk the passes and run them
+ for idx, (pss, pass_desc) in enumerate(self.passes):
+ try:
+ event("-- %s" % pass_desc)
+ pass_inst = _pass_registry.get(pss).pass_inst
+ if isinstance(pass_inst, CompilerPass):
+ self._runPass(idx, pass_inst, state)
+ else:
+ raise BaseException("Legacy pass in use")
+ except _EarlyPipelineCompletion as e:
+ raise e
+ except Exception as e:
+ if not isinstance(e, errors.NumbaError):
+ raise e
+ msg = "Failed in %s mode pipeline (step: %s)" % \
+ (self.pipeline_name, pass_desc)
+ patched_exception = self._patch_error(msg, e)
+ raise patched_exception
+
+ def dependency_analysis(self):
+ """
+ Computes dependency analysis
+ """
+ deps = dict()
+ for (pss, _) in self.passes:
+ x = _pass_registry.get(pss).pass_inst
+ au = AnalysisUsage()
+ x.get_analysis_usage(au)
+ deps[type(x)] = au
+
+ requires_map = dict()
+ for k, v in deps.items():
+ requires_map[k] = v.get_required_set()
+
+ def resolve_requires(key, rmap):
+ def walk(lkey, rmap):
+ dep_set = rmap[lkey] if lkey in rmap else set()
+ if dep_set:
+ for x in dep_set:
+ dep_set |= (walk(x, rmap))
+ return dep_set
+ else:
+ return set()
+ ret = set()
+ for k in key:
+ ret |= walk(k, rmap)
+ return ret
+
+ dep_chain = dict()
+ for k, v in requires_map.items():
+ dep_chain[k] = set(v) | (resolve_requires(v, requires_map))
+
+ return dep_chain
+
+
+pass_info = namedtuple('pass_info', 'pass_inst mutates_CFG analysis_only')
+
+
+class PassRegistry(object):
+ """
+ Pass registry singleton class.
+ """
+
+ _id = 0
+
+ _registry = dict()
+
+ def register(self, mutates_CFG, analysis_only):
+ def make_festive(pass_class):
+ assert not self.is_registered(pass_class)
+ assert not self._does_pass_name_alias(pass_class.name())
+ pass_class.pass_id = self._id
+ self._id += 1
+ self._registry[pass_class] = pass_info(pass_class(), mutates_CFG,
+ analysis_only)
+ return pass_class
+ return make_festive
+
+ def is_registered(self, clazz):
+ return clazz in self._registry.keys()
+
+ def get(self, clazz):
+ assert self.is_registered(clazz)
+ return self._registry[clazz]
+
+ def _does_pass_name_alias(self, check):
+ for k, v in self._registry.items():
+ if v.pass_inst.name == check:
+ return True
+ return False
+
+ def find_by_name(self, class_name):
+ assert isinstance(class_name, str)
+ for k, v in self._registry.items():
+ if v.pass_inst.name == class_name:
+ return v
+ else:
+ raise ValueError("No pass with name %s is registered" % class_name)
+
+ def dump(self):
+ for k, v in self._registry.items():
+ print("%s: %s" % (k, v))
+
+
+_pass_registry = PassRegistry()
+del PassRegistry
+
+
+"""
+register_pass is used to register a compiler pass class for use with PassManager
+instances.
+"""
+register_pass = _pass_registry.register
diff --git a/venv/lib/python3.10/site-packages/numba/core/config.py b/venv/lib/python3.10/site-packages/numba/core/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad7deab48fd2a1a8827bb8ea06eb051a2d0769f5
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/config.py
@@ -0,0 +1,592 @@
+import platform
+import sys
+import os
+import re
+import shutil
+import warnings
+import traceback
+
+# YAML needed to use file based Numba config
+try:
+ import yaml
+ _HAVE_YAML = True
+except ImportError:
+ _HAVE_YAML = False
+
+
+import llvmlite.binding as ll
+
+
+IS_WIN32 = sys.platform.startswith('win32')
+IS_OSX = sys.platform.startswith('darwin')
+MACHINE_BITS = tuple.__itemsize__ * 8
+IS_32BITS = MACHINE_BITS == 32
+# Python version in (major, minor) tuple
+PYVERSION = sys.version_info[:2]
+
+# this is the name of the user supplied configuration file
+_config_fname = '.numba_config.yaml'
+
+
+def _parse_cc(text):
+ """
+ Parse CUDA compute capability version string.
+ """
+ if not text:
+ return None
+ else:
+ m = re.match(r'(\d+)\.(\d+)', text)
+ if not m:
+ raise ValueError("Compute capability must be specified as a "
+ "string of \"major.minor\" where major "
+ "and minor are decimals")
+ grp = m.groups()
+ return int(grp[0]), int(grp[1])
+
+
+def _os_supports_avx():
+ """
+ Whether the current OS supports AVX, regardless of the CPU.
+
+ This is necessary because the user may be running a very old Linux
+ kernel (e.g. CentOS 5) on a recent CPU.
+ """
+ if (not sys.platform.startswith('linux')
+ or platform.machine() not in ('i386', 'i586', 'i686', 'x86_64')):
+ return True
+ # Executing the CPUID instruction may report AVX available even though
+ # the kernel doesn't support it, so parse /proc/cpuinfo instead.
+ try:
+ f = open('/proc/cpuinfo', 'r')
+ except OSError:
+ # If /proc isn't available, assume yes
+ return True
+ with f:
+ for line in f:
+ head, _, body = line.partition(':')
+ if head.strip() == 'flags' and 'avx' in body.split():
+ return True
+ else:
+ return False
+
+
+class _OptLevel(int):
+ """This class holds the "optimisation level" set in `NUMBA_OPT`. As this env
+ var can be an int or a string, but is almost always interpreted as an int,
+ this class subclasses int so as to get the common behaviour but stores the
+ actual value as a `_raw_value` member. The value "max" is a special case
+ and the property `is_opt_max` can be queried to find if the optimisation
+ level (supplied value at construction time) is "max"."""
+
+ def __new__(cls, *args, **kwargs):
+ assert len(args) == 1
+ (value,) = args
+ _int_value = 3 if value == 'max' else int(value)
+ # the int ctor is always called with an appropriate integer value
+ new = super().__new__(cls, _int_value, **kwargs)
+ # raw value is max or int
+ new._raw_value = value if value == 'max' else _int_value
+ return new
+
+ @property
+ def is_opt_max(self):
+ """Returns True if the the optimisation level is "max" False
+ otherwise."""
+ return self._raw_value == "max"
+
+ def __repr__(self):
+ if isinstance(self._raw_value, str):
+ arg = f"'{self._raw_value}'"
+ else:
+ arg = self._raw_value
+ return f"_OptLevel({arg})"
+
+
+def _process_opt_level(opt_level):
+
+ if opt_level not in ('0', '1', '2', '3', 'max'):
+ msg = ("Environment variable `NUMBA_OPT` is set to an unsupported "
+ f"value '{opt_level}', supported values are 0, 1, 2, 3, and "
+ "'max'")
+ raise ValueError(msg)
+ else:
+ return _OptLevel(opt_level)
+
+
+class _EnvReloader(object):
+
+ def __init__(self):
+ self.reset()
+
+ def reset(self):
+ self.old_environ = {}
+ self.update(force=True)
+
+ def update(self, force=False):
+ new_environ = {}
+
+ # first check if there's a .numba_config.yaml and use values from that
+ if os.path.exists(_config_fname) and os.path.isfile(_config_fname):
+ if not _HAVE_YAML:
+ msg = ("A Numba config file is found but YAML parsing "
+ "capabilities appear to be missing. "
+ "To use this feature please install `pyyaml`. e.g. "
+ "`conda install pyyaml`.")
+ warnings.warn(msg)
+ else:
+ with open(_config_fname, 'rt') as f:
+ y_conf = yaml.safe_load(f)
+ if y_conf is not None:
+ for k, v in y_conf.items():
+ new_environ['NUMBA_' + k.upper()] = v
+
+ # clobber file based config with any locally defined env vars
+ for name, value in os.environ.items():
+ if name.startswith('NUMBA_'):
+ new_environ[name] = value
+ # We update the config variables if at least one NUMBA environment
+ # variable was modified. This lets the user modify values
+ # directly in the config module without having them when
+ # reload_config() is called by the compiler.
+ if force or self.old_environ != new_environ:
+ self.process_environ(new_environ)
+ # Store a copy
+ self.old_environ = dict(new_environ)
+
+ self.validate()
+
+ def validate(self):
+ global CUDA_USE_NVIDIA_BINDING
+
+ if CUDA_USE_NVIDIA_BINDING: # noqa: F821
+ try:
+ import cuda # noqa: F401
+ except ImportError as ie:
+ msg = ("CUDA Python bindings requested (the environment "
+ "variable NUMBA_CUDA_USE_NVIDIA_BINDING is set), "
+ f"but they are not importable: {ie.msg}.")
+ warnings.warn(msg)
+
+ CUDA_USE_NVIDIA_BINDING = False
+
+ if CUDA_PER_THREAD_DEFAULT_STREAM: # noqa: F821
+ warnings.warn("PTDS support is handled by CUDA Python when "
+ "using the NVIDIA binding. Please set the "
+ "environment variable "
+ "CUDA_PYTHON_CUDA_PER_THREAD_DEFAULT_STREAM to 1 "
+ "instead.")
+
+ def process_environ(self, environ):
+ def _readenv(name, ctor, default):
+ value = environ.get(name)
+ if value is None:
+ return default() if callable(default) else default
+ try:
+ return ctor(value)
+ except Exception:
+ warnings.warn(f"Environment variable '{name}' is defined but "
+ f"its associated value '{value}' could not be "
+ "parsed.\nThe parse failed with exception:\n"
+ f"{traceback.format_exc()}",
+ RuntimeWarning)
+ return default
+
+ def optional_str(x):
+ return str(x) if x is not None else None
+
+ # Type casting rules selection
+ USE_LEGACY_TYPE_SYSTEM = _readenv(
+ "NUMBA_USE_LEGACY_TYPE_SYSTEM", int, 1
+ )
+
+ # developer mode produces full tracebacks, disables help instructions
+ DEVELOPER_MODE = _readenv("NUMBA_DEVELOPER_MODE", int, 0)
+
+ # disable performance warnings, will switch of the generation of
+ # warnings of the class NumbaPerformanceWarning
+ DISABLE_PERFORMANCE_WARNINGS = _readenv(
+ "NUMBA_DISABLE_PERFORMANCE_WARNINGS", int, 0)
+
+ # Flag to enable full exception reporting
+ FULL_TRACEBACKS = _readenv(
+ "NUMBA_FULL_TRACEBACKS", int, DEVELOPER_MODE)
+
+ # Show help text when an error occurs
+ SHOW_HELP = _readenv("NUMBA_SHOW_HELP", int, 0)
+
+ # The color scheme to use for error messages, default is no color
+ # just bold fonts in use.
+ COLOR_SCHEME = _readenv("NUMBA_COLOR_SCHEME", str, "no_color")
+
+ # Whether to globally enable bounds checking. The default None means
+ # to use the value of the flag to @njit. 0 or 1 overrides the flag
+ # globally.
+ BOUNDSCHECK = _readenv("NUMBA_BOUNDSCHECK", int, None)
+
+ # Whether to always warn about potential uninitialized variables
+ # because static controlflow analysis cannot find a definition
+ # in one or more of the incoming paths.
+ ALWAYS_WARN_UNINIT_VAR = _readenv(
+ "NUMBA_ALWAYS_WARN_UNINIT_VAR", int, 0,
+ )
+
+ # Whether to warn about kernel launches where the grid size will
+ # under utilize the GPU due to low occupancy. On by default.
+ CUDA_LOW_OCCUPANCY_WARNINGS = _readenv(
+ "NUMBA_CUDA_LOW_OCCUPANCY_WARNINGS", int, 1)
+
+ # Whether to use the official CUDA Python API Bindings
+ CUDA_USE_NVIDIA_BINDING = _readenv(
+ "NUMBA_CUDA_USE_NVIDIA_BINDING", int, 0)
+
+ # Debug flag to control compiler debug print
+ DEBUG = _readenv("NUMBA_DEBUG", int, 0)
+
+ # DEBUG print IR after pass names
+ DEBUG_PRINT_AFTER = _readenv("NUMBA_DEBUG_PRINT_AFTER", str, "none")
+
+ # DEBUG print IR before pass names
+ DEBUG_PRINT_BEFORE = _readenv("NUMBA_DEBUG_PRINT_BEFORE", str, "none")
+
+ # DEBUG print IR before and after pass names
+ DEBUG_PRINT_WRAP = _readenv("NUMBA_DEBUG_PRINT_WRAP", str, "none")
+
+ # Highlighting in intermediate dumps
+ HIGHLIGHT_DUMPS = _readenv("NUMBA_HIGHLIGHT_DUMPS", int, 0)
+
+ # JIT Debug flag to trigger IR instruction print
+ DEBUG_JIT = _readenv("NUMBA_DEBUG_JIT", int, 0)
+
+ # Enable debugging of front-end operation
+ # (up to and including IR generation)
+ DEBUG_FRONTEND = _readenv("NUMBA_DEBUG_FRONTEND", int, 0)
+
+ # Enable debug prints in nrtdynmod and use of "safe" API functions
+ DEBUG_NRT = _readenv("NUMBA_DEBUG_NRT", int, 0)
+
+ # Enable NRT statistics counters
+ NRT_STATS = _readenv("NUMBA_NRT_STATS", int, 0)
+
+ # How many recently deserialized functions to retain regardless
+ # of external references
+ FUNCTION_CACHE_SIZE = _readenv("NUMBA_FUNCTION_CACHE_SIZE", int, 128)
+
+ # Maximum tuple size that parfors will unpack and pass to
+ # internal gufunc.
+ PARFOR_MAX_TUPLE_SIZE = _readenv("NUMBA_PARFOR_MAX_TUPLE_SIZE",
+ int, 100)
+
+ # Enable logging of cache operation
+ DEBUG_CACHE = _readenv("NUMBA_DEBUG_CACHE", int, DEBUG)
+
+ # Redirect cache directory
+ # Contains path to the directory
+ CACHE_DIR = _readenv("NUMBA_CACHE_DIR", str, "")
+
+ # Enable tracing support
+ TRACE = _readenv("NUMBA_TRACE", int, 0)
+
+ # Enable chrome tracing support
+ CHROME_TRACE = _readenv("NUMBA_CHROME_TRACE", str, "")
+
+ # Enable debugging of type inference
+ DEBUG_TYPEINFER = _readenv("NUMBA_DEBUG_TYPEINFER", int, 0)
+
+ # Configure compilation target to use the specified CPU name
+ # and CPU feature as the host information.
+ # Note: this overrides "host" option for AOT compilation.
+ CPU_NAME = _readenv("NUMBA_CPU_NAME", optional_str, None)
+ CPU_FEATURES = _readenv("NUMBA_CPU_FEATURES", optional_str,
+ ("" if str(CPU_NAME).lower() == 'generic'
+ else None))
+ # Optimization level
+ OPT = _readenv("NUMBA_OPT", _process_opt_level, _OptLevel(3))
+
+ # Force dump of Python bytecode
+ DUMP_BYTECODE = _readenv("NUMBA_DUMP_BYTECODE", int, DEBUG_FRONTEND)
+
+ # Force dump of control flow graph
+ DUMP_CFG = _readenv("NUMBA_DUMP_CFG", int, DEBUG_FRONTEND)
+
+ # Force dump of Numba IR
+ DUMP_IR = _readenv("NUMBA_DUMP_IR", int,
+ DEBUG_FRONTEND)
+
+ # Force dump of Numba IR in SSA form
+ DUMP_SSA = _readenv("NUMBA_DUMP_SSA", int,
+ DEBUG_FRONTEND or DEBUG_TYPEINFER)
+
+ # print debug info of analysis and optimization on array operations
+ DEBUG_ARRAY_OPT = _readenv("NUMBA_DEBUG_ARRAY_OPT", int, 0)
+
+ # insert debug stmts to print information at runtime
+ DEBUG_ARRAY_OPT_RUNTIME = _readenv(
+ "NUMBA_DEBUG_ARRAY_OPT_RUNTIME", int, 0)
+
+ # print stats about parallel for-loops
+ DEBUG_ARRAY_OPT_STATS = _readenv("NUMBA_DEBUG_ARRAY_OPT_STATS", int, 0)
+
+ # prints user friendly information about parallel
+ PARALLEL_DIAGNOSTICS = _readenv("NUMBA_PARALLEL_DIAGNOSTICS", int, 0)
+
+ # print debug info of inline closure pass
+ DEBUG_INLINE_CLOSURE = _readenv("NUMBA_DEBUG_INLINE_CLOSURE", int, 0)
+
+ # Force dump of LLVM IR
+ DUMP_LLVM = _readenv("NUMBA_DUMP_LLVM", int, DEBUG)
+
+ # Force dump of Function optimized LLVM IR
+ DUMP_FUNC_OPT = _readenv("NUMBA_DUMP_FUNC_OPT", int, DEBUG)
+
+ # Force dump of Optimized LLVM IR
+ DUMP_OPTIMIZED = _readenv("NUMBA_DUMP_OPTIMIZED", int, DEBUG)
+
+ # Force disable loop vectorize
+ LOOP_VECTORIZE = _readenv("NUMBA_LOOP_VECTORIZE", int, 1)
+
+ # Enable superword-level parallelism vectorization, default is off
+ # since #8705 (miscompilation).
+ SLP_VECTORIZE = _readenv("NUMBA_SLP_VECTORIZE", int, 0)
+
+ # Force dump of generated assembly
+ DUMP_ASSEMBLY = _readenv("NUMBA_DUMP_ASSEMBLY", int, DEBUG)
+
+ # Force dump of type annotation
+ ANNOTATE = _readenv("NUMBA_DUMP_ANNOTATION", int, 0)
+
+ # Dump IR in such as way as to aid in "diff"ing.
+ DIFF_IR = _readenv("NUMBA_DIFF_IR", int, 0)
+
+ # Dump type annotation in html format
+ def fmt_html_path(path):
+ if path is None:
+ return path
+ else:
+ return os.path.abspath(path)
+
+ HTML = _readenv("NUMBA_DUMP_HTML", fmt_html_path, None)
+
+ # x86-64 specific
+ # Enable AVX on supported platforms where it won't degrade performance.
+ def avx_default():
+ if not _os_supports_avx():
+ return False
+ else:
+ # There are various performance issues with AVX and LLVM
+ # on some CPUs (list at
+ # http://llvm.org/bugs/buglist.cgi?quicksearch=avx).
+ # For now we'd rather disable it, since it can pessimize code
+ cpu_name = CPU_NAME or ll.get_host_cpu_name()
+ disabled_cpus = {'corei7-avx', 'core-avx-i',
+ 'sandybridge', 'ivybridge'}
+ # Disable known baseline CPU names that virtual machines may
+ # incorrectly report as having AVX support.
+ # This can cause problems with the SVML-pass's use of AVX512.
+ # See https://github.com/numba/numba/issues/9582
+ disabled_cpus |= {'nocona'}
+ return cpu_name not in disabled_cpus
+
+ ENABLE_AVX = _readenv("NUMBA_ENABLE_AVX", int, avx_default)
+
+ # if set and SVML is available, it will be disabled
+ # By default, it's disabled on 32-bit platforms.
+ DISABLE_INTEL_SVML = _readenv(
+ "NUMBA_DISABLE_INTEL_SVML", int, IS_32BITS)
+
+ # Disable jit for debugging
+ DISABLE_JIT = _readenv("NUMBA_DISABLE_JIT", int, 0)
+
+ # choose parallel backend to use
+ THREADING_LAYER_PRIORITY = _readenv(
+ "NUMBA_THREADING_LAYER_PRIORITY",
+ lambda string: string.split(),
+ ['tbb', 'omp', 'workqueue'],
+ )
+ THREADING_LAYER = _readenv("NUMBA_THREADING_LAYER", str, 'default')
+
+ # CUDA Configs
+
+ # Whether to warn about kernel launches where a host array
+ # is used as a parameter, forcing a copy to and from the device.
+ # On by default.
+ CUDA_WARN_ON_IMPLICIT_COPY = _readenv(
+ "NUMBA_CUDA_WARN_ON_IMPLICIT_COPY", int, 1)
+
+ # Force CUDA compute capability to a specific version
+ FORCE_CUDA_CC = _readenv("NUMBA_FORCE_CUDA_CC", _parse_cc, None)
+
+ # The default compute capability to target when compiling to PTX.
+ CUDA_DEFAULT_PTX_CC = _readenv("NUMBA_CUDA_DEFAULT_PTX_CC", _parse_cc,
+ (5, 0))
+
+ # Disable CUDA support
+ DISABLE_CUDA = _readenv("NUMBA_DISABLE_CUDA",
+ int, int(MACHINE_BITS == 32))
+
+ # Enable CUDA simulator
+ ENABLE_CUDASIM = _readenv("NUMBA_ENABLE_CUDASIM", int, 0)
+
+ # CUDA logging level
+ # Any level name from the *logging* module. Case insensitive.
+ # Defaults to CRITICAL if not set or invalid.
+ # Note: This setting only applies when logging is not configured.
+ # Any existing logging configuration is preserved.
+ CUDA_LOG_LEVEL = _readenv("NUMBA_CUDA_LOG_LEVEL", str, '')
+
+ # Include argument values in the CUDA Driver API logs
+ CUDA_LOG_API_ARGS = _readenv("NUMBA_CUDA_LOG_API_ARGS", int, 0)
+
+ # Maximum number of pending CUDA deallocations (default: 10)
+ CUDA_DEALLOCS_COUNT = _readenv("NUMBA_CUDA_MAX_PENDING_DEALLOCS_COUNT",
+ int, 10)
+
+ # Maximum ratio of pending CUDA deallocations to capacity (default: 0.2)
+ CUDA_DEALLOCS_RATIO = _readenv("NUMBA_CUDA_MAX_PENDING_DEALLOCS_RATIO",
+ float, 0.2)
+
+ CUDA_ARRAY_INTERFACE_SYNC = _readenv("NUMBA_CUDA_ARRAY_INTERFACE_SYNC",
+ int, 1)
+
+ # Path of the directory that the CUDA driver libraries are located
+ CUDA_DRIVER = _readenv("NUMBA_CUDA_DRIVER", str, '')
+
+ # Buffer size for logs produced by CUDA driver operations (e.g.
+ # linking)
+ CUDA_LOG_SIZE = _readenv("NUMBA_CUDA_LOG_SIZE", int, 1024)
+
+ # Whether to generate verbose log messages when JIT linking
+ CUDA_VERBOSE_JIT_LOG = _readenv("NUMBA_CUDA_VERBOSE_JIT_LOG", int, 1)
+
+ # Whether the default stream is the per-thread default stream
+ CUDA_PER_THREAD_DEFAULT_STREAM = _readenv(
+ "NUMBA_CUDA_PER_THREAD_DEFAULT_STREAM", int, 0)
+
+ CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY = _readenv(
+ "NUMBA_CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY", int, 0)
+
+ # Location of the CUDA include files
+ if IS_WIN32:
+ cuda_path = os.environ.get('CUDA_PATH')
+ if cuda_path:
+ default_cuda_include_path = os.path.join(cuda_path, "include")
+ else:
+ default_cuda_include_path = "cuda_include_not_found"
+ else:
+ default_cuda_include_path = os.path.join(os.sep, 'usr', 'local',
+ 'cuda', 'include')
+ CUDA_INCLUDE_PATH = _readenv("NUMBA_CUDA_INCLUDE_PATH", str,
+ default_cuda_include_path)
+
+ # Threading settings
+
+ # The default number of threads to use.
+ def num_threads_default():
+ try:
+ sched_getaffinity = os.sched_getaffinity
+ except AttributeError:
+ pass
+ else:
+ return max(1, len(sched_getaffinity(0)))
+
+ cpu_count = os.cpu_count()
+ if cpu_count is not None:
+ return max(1, cpu_count)
+
+ return 1
+
+ NUMBA_DEFAULT_NUM_THREADS = num_threads_default()
+
+ # Numba thread pool size (defaults to number of CPUs on the system).
+ _NUMBA_NUM_THREADS = _readenv("NUMBA_NUM_THREADS", int,
+ NUMBA_DEFAULT_NUM_THREADS)
+ if ('NUMBA_NUM_THREADS' in globals()
+ and globals()['NUMBA_NUM_THREADS'] != _NUMBA_NUM_THREADS):
+
+ from numba.np.ufunc import parallel
+ if parallel._is_initialized:
+ raise RuntimeError("Cannot set NUMBA_NUM_THREADS to a "
+ "different value once the threads have been "
+ "launched (currently have %s, "
+ "trying to set %s)" %
+ (_NUMBA_NUM_THREADS,
+ globals()['NUMBA_NUM_THREADS']))
+
+ NUMBA_NUM_THREADS = _NUMBA_NUM_THREADS
+ del _NUMBA_NUM_THREADS
+
+ # sys.monitoring support
+ ENABLE_SYS_MONITORING = _readenv("NUMBA_ENABLE_SYS_MONITORING",
+ int, 0)
+
+ # Profiling support
+
+ # Indicates if a profiler detected. Only VTune can be detected for now
+ RUNNING_UNDER_PROFILER = 'VS_PROFILER' in os.environ
+
+ # Enables jit events in LLVM to support profiling of dynamic code
+ ENABLE_PROFILING = _readenv(
+ "NUMBA_ENABLE_PROFILING", int, int(RUNNING_UNDER_PROFILER))
+
+ # Debug Info
+
+ # The default value for the `debug` flag
+ DEBUGINFO_DEFAULT = _readenv("NUMBA_DEBUGINFO", int, ENABLE_PROFILING)
+ CUDA_DEBUGINFO_DEFAULT = _readenv("NUMBA_CUDA_DEBUGINFO", int, 0)
+
+ EXTEND_VARIABLE_LIFETIMES = _readenv("NUMBA_EXTEND_VARIABLE_LIFETIMES",
+ int, 0)
+
+ # gdb binary location
+ def which_gdb(path_or_bin):
+ gdb = shutil.which(path_or_bin)
+ return gdb if gdb is not None else path_or_bin
+
+ GDB_BINARY = _readenv("NUMBA_GDB_BINARY", which_gdb, 'gdb')
+
+ # CUDA Memory management
+ CUDA_MEMORY_MANAGER = _readenv("NUMBA_CUDA_MEMORY_MANAGER", str,
+ 'default')
+
+ # Experimental refprune pass
+ LLVM_REFPRUNE_PASS = _readenv(
+ "NUMBA_LLVM_REFPRUNE_PASS", int, 1,
+ )
+ LLVM_REFPRUNE_FLAGS = _readenv(
+ "NUMBA_LLVM_REFPRUNE_FLAGS", str,
+ "all" if LLVM_REFPRUNE_PASS else "",
+ )
+
+ # llvmlite memory manager
+ USE_LLVMLITE_MEMORY_MANAGER = _readenv(
+ "NUMBA_USE_LLVMLITE_MEMORY_MANAGER", int, None
+ )
+
+ # Timing support.
+
+ # LLVM_PASS_TIMINGS enables LLVM recording of pass timings.
+ LLVM_PASS_TIMINGS = _readenv(
+ "NUMBA_LLVM_PASS_TIMINGS", int, 0,
+ )
+
+ # Coverage support.
+
+ # JIT_COVERAGE (bool) controls whether the compiler report compiled
+ # lines to coverage tools. Defaults to off.
+ JIT_COVERAGE = _readenv(
+ "NUMBA_JIT_COVERAGE", int, 0,
+ )
+
+ # Inject the configuration values into the module globals
+ for name, value in locals().copy().items():
+ if name.isupper():
+ globals()[name] = value
+
+
+_env_reloader = _EnvReloader()
+
+
+def reload_config():
+ """
+ Reload the configuration from environment variables, if necessary.
+ """
+ _env_reloader.update()
diff --git a/venv/lib/python3.10/site-packages/numba/core/consts.py b/venv/lib/python3.10/site-packages/numba/core/consts.py
new file mode 100644
index 0000000000000000000000000000000000000000..d062b320893e5902ff828f68bc7d8b4221a8a9a1
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/consts.py
@@ -0,0 +1,118 @@
+from types import ModuleType
+
+import weakref
+
+from numba.core.errors import ConstantInferenceError, NumbaError
+from numba.core import ir
+
+
+class ConstantInference(object):
+ """
+ A constant inference engine for a given interpreter.
+ Inference inspects the IR to try and compute a compile-time constant for
+ a variable.
+
+ This shouldn't be used directly, instead call Interpreter.infer_constant().
+ """
+
+ def __init__(self, func_ir):
+ # Avoid cyclic references as some user-visible objects may be
+ # held alive in the cache
+ self._func_ir = weakref.proxy(func_ir)
+ self._cache = {}
+
+ def infer_constant(self, name, loc=None):
+ """
+ Infer a constant value for the given variable *name*.
+ If no value can be inferred, numba.errors.ConstantInferenceError
+ is raised.
+ """
+ if name not in self._cache:
+ try:
+ self._cache[name] = (True, self._do_infer(name))
+ except ConstantInferenceError as exc:
+ # Store the exception args only, to avoid keeping
+ # a whole traceback alive.
+ self._cache[name] = (False, (exc.__class__, exc.args))
+ success, val = self._cache[name]
+ if success:
+ return val
+ else:
+ exc, args = val
+ if issubclass(exc, NumbaError):
+ raise exc(*args, loc=loc)
+ else:
+ raise exc(*args)
+
+ def _fail(self, val):
+ # The location here is set to None because `val` is the ir.Var name
+ # and not the actual offending use of the var. When this is raised it is
+ # caught in the flow control of `infer_constant` and the class and args
+ # (the message) are captured and then raised again but with the location
+ # set to the expression that caused the constant inference error.
+ raise ConstantInferenceError(
+ "Constant inference not possible for: %s" % (val,), loc=None)
+
+ def _do_infer(self, name):
+ if not isinstance(name, str):
+ raise TypeError("infer_constant() called with non-str %r"
+ % (name,))
+ try:
+ defn = self._func_ir.get_definition(name)
+ except KeyError:
+ raise ConstantInferenceError(
+ "no single definition for %r" % (name,))
+ try:
+ const = defn.infer_constant()
+ except ConstantInferenceError:
+ if isinstance(defn, ir.Expr):
+ return self._infer_expr(defn)
+ self._fail(defn)
+ return const
+
+ def _infer_expr(self, expr):
+ # Infer an expression: handle supported cases
+ if expr.op == 'call':
+ func = self.infer_constant(expr.func.name, loc=expr.loc)
+ return self._infer_call(func, expr)
+ elif expr.op == 'getattr':
+ value = self.infer_constant(expr.value.name, loc=expr.loc)
+ return self._infer_getattr(value, expr)
+ elif expr.op == 'build_list':
+ return [self.infer_constant(i.name, loc=expr.loc) for i in
+ expr.items]
+ elif expr.op == 'build_tuple':
+ return tuple(self.infer_constant(i.name, loc=expr.loc) for i in
+ expr.items)
+ self._fail(expr)
+
+ def _infer_call(self, func, expr):
+ if expr.kws or expr.vararg:
+ self._fail(expr)
+ # Check supported callables
+ _slice = func in (slice,)
+ _exc = isinstance(func, type) and issubclass(func, BaseException)
+ if _slice or _exc:
+ args = [self.infer_constant(a.name, loc=expr.loc) for a in
+ expr.args]
+ if _slice:
+ return func(*args)
+ elif _exc:
+ # If the exception class is user defined it may implement a ctor
+ # that does not pass the args to the super. Therefore return the
+ # raw class and the args so this can be instantiated at the call
+ # site in the way the user source expects it to be.
+ return func, args
+ else:
+ assert 0, 'Unreachable'
+
+ self._fail(expr)
+
+ def _infer_getattr(self, value, expr):
+ if isinstance(value, (ModuleType, type)):
+ # Allow looking up a constant on a class or module
+ try:
+ return getattr(value, expr.attr)
+ except AttributeError:
+ pass
+ self._fail(expr)
diff --git a/venv/lib/python3.10/site-packages/numba/core/controlflow.py b/venv/lib/python3.10/site-packages/numba/core/controlflow.py
new file mode 100644
index 0000000000000000000000000000000000000000..01db54e282a6cf49e5e4a698be6bb332befa6a58
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/controlflow.py
@@ -0,0 +1,972 @@
+import collections
+import functools
+import sys
+
+from numba.core.ir import Loc
+from numba.core.errors import UnsupportedError
+from numba.core.utils import PYVERSION
+
+# List of bytecodes creating a new block in the control flow graph
+# (in addition to explicit jump labels).
+NEW_BLOCKERS = frozenset([
+ 'SETUP_LOOP', 'FOR_ITER', 'SETUP_WITH', 'BEFORE_WITH'
+])
+
+
+class CFBlock(object):
+
+ def __init__(self, offset):
+ self.offset = offset
+ self.body = []
+ # A map of jumps to outgoing blocks (successors):
+ # { offset of outgoing block -> number of stack pops }
+ self.outgoing_jumps = {}
+ # A map of jumps to incoming blocks (predecessors):
+ # { offset of incoming block -> number of stack pops }
+ self.incoming_jumps = {}
+ self.terminating = False
+
+ def __repr__(self):
+ args = (self.offset,
+ sorted(self.outgoing_jumps),
+ sorted(self.incoming_jumps))
+ return "block(offset:%d, outgoing: %s, incoming: %s)" % args
+
+ def __iter__(self):
+ return iter(self.body)
+
+
+class Loop(collections.namedtuple("Loop",
+ ("entries", "exits", "header", "body"))):
+ """
+ A control flow loop, as detected by a CFGraph object.
+ """
+
+ __slots__ = ()
+
+ # The loop header is enough to detect that two loops are really
+ # the same, assuming they belong to the same graph.
+ # (note: in practice, only one loop instance is created per graph
+ # loop, so identity would be fine)
+
+ def __eq__(self, other):
+ return isinstance(other, Loop) and other.header == self.header
+
+ def __hash__(self):
+ return hash(self.header)
+
+
+class _DictOfContainers(collections.defaultdict):
+ """A defaultdict with customized equality checks that ignore empty values.
+
+ Non-empty value is checked by: `bool(value_item) == True`.
+ """
+
+ def __eq__(self, other):
+ if isinstance(other, _DictOfContainers):
+ mine = self._non_empty_items()
+ theirs = other._non_empty_items()
+ return mine == theirs
+
+ return NotImplemented
+
+ def __ne__(self, other):
+ ret = self.__eq__(other)
+ if ret is NotImplemented:
+ return ret
+ else:
+ return not ret
+
+ def _non_empty_items(self):
+ return [(k, vs) for k, vs in sorted(self.items()) if vs]
+
+
+class CFGraph(object):
+ """
+ Generic (almost) implementation of a Control Flow Graph.
+ """
+
+ def __init__(self):
+ self._nodes = set()
+ self._preds = _DictOfContainers(set)
+ self._succs = _DictOfContainers(set)
+ self._edge_data = {}
+ self._entry_point = None
+
+ def add_node(self, node):
+ """
+ Add *node* to the graph. This is necessary before adding any
+ edges from/to the node. *node* can be any hashable object.
+ """
+ self._nodes.add(node)
+
+ def add_edge(self, src, dest, data=None):
+ """
+ Add an edge from node *src* to node *dest*, with optional
+ per-edge *data*.
+ If such an edge already exists, it is replaced (duplicate edges
+ are not possible).
+ """
+ if src not in self._nodes:
+ raise ValueError("Cannot add edge as src node %s not in nodes %s" %
+ (src, self._nodes))
+ if dest not in self._nodes:
+ raise ValueError("Cannot add edge as dest node %s not in nodes %s" %
+ (dest, self._nodes))
+ self._add_edge(src, dest, data)
+
+ def successors(self, src):
+ """
+ Yield (node, data) pairs representing the successors of node *src*.
+ (*data* will be None if no data was specified when adding the edge)
+ """
+ for dest in self._succs[src]:
+ yield dest, self._edge_data[src, dest]
+
+ def predecessors(self, dest):
+ """
+ Yield (node, data) pairs representing the predecessors of node *dest*.
+ (*data* will be None if no data was specified when adding the edge)
+ """
+ for src in self._preds[dest]:
+ yield src, self._edge_data[src, dest]
+
+ def set_entry_point(self, node):
+ """
+ Set the entry point of the graph to *node*.
+ """
+ assert node in self._nodes
+ self._entry_point = node
+
+ def process(self):
+ """
+ Compute essential properties of the control flow graph. The graph
+ must have been fully populated, and its entry point specified. Other
+ graph properties are computed on-demand.
+ """
+ if self._entry_point is None:
+ raise RuntimeError("no entry point defined!")
+ self._eliminate_dead_blocks()
+
+ def dominators(self):
+ """
+ Return a dictionary of {node -> set(nodes)} mapping each node to
+ the nodes dominating it.
+
+ A node D dominates a node N when any path leading to N must go through D
+ """
+ return self._doms
+
+ def post_dominators(self):
+ """
+ Return a dictionary of {node -> set(nodes)} mapping each node to
+ the nodes post-dominating it.
+
+ A node P post-dominates a node N when any path starting from N must go
+ through P.
+ """
+ return self._post_doms
+
+ def immediate_dominators(self):
+ """
+ Return a dictionary of {node -> node} mapping each node to its
+ immediate dominator (idom).
+
+ The idom(B) is the closest strict dominator of V
+ """
+ return self._idom
+
+ def dominance_frontier(self):
+ """
+ Return a dictionary of {node -> set(nodes)} mapping each node to
+ the nodes in its dominance frontier.
+
+ The dominance frontier _df(N) is the set of all nodes that are
+ immediate successors to blocks dominated by N but which aren't
+ strictly dominated by N
+ """
+ return self._df
+
+ def dominator_tree(self):
+ """
+ return a dictionary of {node -> set(nodes)} mapping each node to
+ the set of nodes it immediately dominates
+
+ The domtree(B) is the closest strict set of nodes that B dominates
+ """
+ return self._domtree
+
+ @functools.cached_property
+ def _exit_points(self):
+ return self._find_exit_points()
+
+ @functools.cached_property
+ def _doms(self):
+ return self._find_dominators()
+
+ @functools.cached_property
+ def _back_edges(self):
+ return self._find_back_edges()
+
+ @functools.cached_property
+ def _topo_order(self):
+ return self._find_topo_order()
+
+ @functools.cached_property
+ def _descs(self):
+ return self._find_descendents()
+
+ @functools.cached_property
+ def _loops(self):
+ return self._find_loops()
+
+ @functools.cached_property
+ def _in_loops(self):
+ return self._find_in_loops()
+
+ @functools.cached_property
+ def _post_doms(self):
+ return self._find_post_dominators()
+
+ @functools.cached_property
+ def _idom(self):
+ return self._find_immediate_dominators()
+
+ @functools.cached_property
+ def _df(self):
+ return self._find_dominance_frontier()
+
+ @functools.cached_property
+ def _domtree(self):
+ return self._find_dominator_tree()
+
+ def descendents(self, node):
+ """
+ Return the set of descendents of the given *node*, in topological
+ order (ignoring back edges).
+ """
+ return self._descs[node]
+
+ def entry_point(self):
+ """
+ Return the entry point node.
+ """
+ assert self._entry_point is not None
+ return self._entry_point
+
+ def exit_points(self):
+ """
+ Return the computed set of exit nodes (may be empty).
+ """
+ return self._exit_points
+
+ def backbone(self):
+ """
+ Return the set of nodes constituting the graph's backbone.
+ (i.e. the nodes that every path starting from the entry point
+ must go through). By construction, it is non-empty: it contains
+ at least the entry point.
+ """
+ return self._post_doms[self._entry_point]
+
+ def loops(self):
+ """
+ Return a dictionary of {node -> loop} mapping each loop header
+ to the loop (a Loop instance) starting with it.
+ """
+ return self._loops
+
+ def in_loops(self, node):
+ """
+ Return the list of Loop objects the *node* belongs to,
+ from innermost to outermost.
+ """
+ return [self._loops[x] for x in self._in_loops.get(node, ())]
+
+ def dead_nodes(self):
+ """
+ Return the set of dead nodes (eliminated from the graph).
+ """
+ return self._dead_nodes
+
+ def nodes(self):
+ """
+ Return the set of live nodes.
+ """
+ return self._nodes
+
+ def topo_order(self):
+ """
+ Return the sequence of nodes in topological order (ignoring back
+ edges).
+ """
+ return self._topo_order
+
+ def topo_sort(self, nodes, reverse=False):
+ """
+ Iterate over the *nodes* in topological order (ignoring back edges).
+ The sort isn't guaranteed to be stable.
+ """
+ nodes = set(nodes)
+ it = self._topo_order
+ if reverse:
+ it = reversed(it)
+ for n in it:
+ if n in nodes:
+ yield n
+
+ def dump(self, file=None):
+ """
+ Dump extensive debug information.
+ """
+ import pprint
+ file = file or sys.stdout
+ if 1:
+ print("CFG adjacency lists:", file=file)
+ self._dump_adj_lists(file)
+ print("CFG dominators:", file=file)
+ pprint.pprint(self._doms, stream=file)
+ print("CFG post-dominators:", file=file)
+ pprint.pprint(self._post_doms, stream=file)
+ print("CFG back edges:", sorted(self._back_edges), file=file)
+ print("CFG loops:", file=file)
+ pprint.pprint(self._loops, stream=file)
+ print("CFG node-to-loops:", file=file)
+ pprint.pprint(self._in_loops, stream=file)
+ print("CFG backbone:", file=file)
+ pprint.pprint(self.backbone(), stream=file)
+
+ def render_dot(self, filename="numba_cfg.dot"):
+ """Render the controlflow graph with GraphViz DOT via the
+ ``graphviz`` python binding.
+
+ Returns
+ -------
+ g : graphviz.Digraph
+ Use `g.view()` to open the graph in the default PDF application.
+ """
+
+ try:
+ import graphviz as gv
+ except ImportError:
+ raise ImportError(
+ "The feature requires `graphviz` but it is not available. "
+ "Please install with `pip install graphviz`"
+ )
+ g = gv.Digraph(filename=filename)
+ # Populate the nodes
+ for n in self._nodes:
+ g.node(str(n))
+ # Populate the edges
+ for n in self._nodes:
+ for edge in self._succs[n]:
+ g.edge(str(n), str(edge))
+ return g
+
+ # Internal APIs
+
+ def _add_edge(self, from_, to, data=None):
+ # This internal version allows adding edges to/from unregistered
+ # (ghost) nodes.
+ self._preds[to].add(from_)
+ self._succs[from_].add(to)
+ self._edge_data[from_, to] = data
+
+ def _remove_node_edges(self, node):
+ for succ in self._succs.pop(node, ()):
+ self._preds[succ].remove(node)
+ del self._edge_data[node, succ]
+ for pred in self._preds.pop(node, ()):
+ self._succs[pred].remove(node)
+ del self._edge_data[pred, node]
+
+ def _dfs(self, entries=None):
+ if entries is None:
+ entries = (self._entry_point,)
+ seen = set()
+ stack = list(entries)
+ while stack:
+ node = stack.pop()
+ if node not in seen:
+ yield node
+ seen.add(node)
+ for succ in self._succs[node]:
+ stack.append(succ)
+
+ def _eliminate_dead_blocks(self):
+ """
+ Eliminate all blocks not reachable from the entry point, and
+ stash them into self._dead_nodes.
+ """
+ live = set()
+ for node in self._dfs():
+ live.add(node)
+ self._dead_nodes = self._nodes - live
+ self._nodes = live
+ # Remove all edges leading from dead nodes
+ for dead in self._dead_nodes:
+ self._remove_node_edges(dead)
+
+ def _find_exit_points(self):
+ """
+ Compute the graph's exit points.
+ """
+ exit_points = set()
+ for n in self._nodes:
+ if not self._succs.get(n):
+ exit_points.add(n)
+ return exit_points
+
+ def _find_postorder(self):
+ succs = self._succs
+ back_edges = self._back_edges
+ post_order = []
+ seen = set()
+
+ post_order = []
+
+ # DFS
+ def dfs_rec(node):
+ if node not in seen:
+ seen.add(node)
+ stack.append((post_order.append, node))
+ for dest in succs[node]:
+ if (node, dest) not in back_edges:
+ stack.append((dfs_rec, dest))
+
+ stack = [(dfs_rec, self._entry_point)]
+ while stack:
+ cb, data = stack.pop()
+ cb(data)
+
+ return post_order
+
+ def _find_immediate_dominators(self):
+ # The algorithm implemented computes the immediate dominator
+ # for each node in the CFG which is equivalent to build a dominator tree
+ # Based on the implementation from NetworkX
+ # library - nx.immediate_dominators
+ # https://github.com/networkx/networkx/blob/858e7cb183541a78969fed0cbcd02346f5866c02/networkx/algorithms/dominance.py # noqa: E501
+ # References:
+ # Keith D. Cooper, Timothy J. Harvey, and Ken Kennedy
+ # A Simple, Fast Dominance Algorithm
+ # https://www.cs.rice.edu/~keith/EMBED/dom.pdf
+ def intersect(u, v):
+ while u != v:
+ while idx[u] < idx[v]:
+ u = idom[u]
+ while idx[u] > idx[v]:
+ v = idom[v]
+ return u
+
+ entry = self._entry_point
+ preds_table = self._preds
+
+ order = self._find_postorder()
+ idx = {e: i for i, e in enumerate(order)} # index of each node
+ idom = {entry : entry}
+ order.pop()
+ order.reverse()
+
+ changed = True
+ while changed:
+ changed = False
+ for u in order:
+ new_idom = functools.reduce(intersect,
+ (v for v in preds_table[u]
+ if v in idom))
+ if u not in idom or idom[u] != new_idom:
+ idom[u] = new_idom
+ changed = True
+
+ return idom
+
+ def _find_dominator_tree(self):
+ idom = self._idom
+ domtree = _DictOfContainers(set)
+
+ for u, v in idom.items():
+ # v dominates u
+ if u not in domtree:
+ domtree[u] = set()
+ if u != v:
+ domtree[v].add(u)
+
+ return domtree
+
+ def _find_dominance_frontier(self):
+ idom = self._idom
+ preds_table = self._preds
+ df = {u: set() for u in idom}
+
+ for u in idom:
+ if len(preds_table[u]) < 2:
+ continue
+ for v in preds_table[u]:
+ while v != idom[u]:
+ df[v].add(u)
+ v = idom[v]
+
+ return df
+
+ def _find_dominators_internal(self, post=False):
+ # See theoretical description in
+ # http://en.wikipedia.org/wiki/Dominator_%28graph_theory%29
+ # The algorithm implemented here uses a todo-list as described
+ # in http://pages.cs.wisc.edu/~fischer/cs701.f08/finding.loops.html
+ if post:
+ entries = set(self._exit_points)
+ preds_table = self._succs
+ succs_table = self._preds
+ else:
+ entries = set([self._entry_point])
+ preds_table = self._preds
+ succs_table = self._succs
+
+ if not entries:
+ raise RuntimeError("no entry points: dominator algorithm "
+ "cannot be seeded")
+
+ doms = {}
+ for e in entries:
+ doms[e] = set([e])
+
+ todo = []
+ for n in self._nodes:
+ if n not in entries:
+ doms[n] = set(self._nodes)
+ todo.append(n)
+
+ while todo:
+ n = todo.pop()
+ if n in entries:
+ continue
+ new_doms = set([n])
+ preds = preds_table[n]
+ if preds:
+ new_doms |= functools.reduce(set.intersection,
+ [doms[p] for p in preds])
+ if new_doms != doms[n]:
+ assert len(new_doms) < len(doms[n])
+ doms[n] = new_doms
+ todo.extend(succs_table[n])
+ return doms
+
+ def _find_dominators(self):
+ return self._find_dominators_internal(post=False)
+
+ def _find_post_dominators(self):
+ # To handle infinite loops correctly, we need to add a dummy
+ # exit point, and link members of infinite loops to it.
+ dummy_exit = object()
+ self._exit_points.add(dummy_exit)
+ for loop in self._loops.values():
+ if not loop.exits:
+ for b in loop.body:
+ self._add_edge(b, dummy_exit)
+ pdoms = self._find_dominators_internal(post=True)
+ # Fix the _post_doms table to make no reference to the dummy exit
+ del pdoms[dummy_exit]
+ for doms in pdoms.values():
+ doms.discard(dummy_exit)
+ self._remove_node_edges(dummy_exit)
+ self._exit_points.remove(dummy_exit)
+ return pdoms
+
+ # Finding loops and back edges: see
+ # http://pages.cs.wisc.edu/~fischer/cs701.f08/finding.loops.html
+
+ def _find_back_edges(self, stats=None):
+ """
+ Find back edges. An edge (src, dest) is a back edge if and
+ only if *dest* dominates *src*.
+ """
+ # Prepare stats to capture execution information
+ if stats is not None:
+ if not isinstance(stats, dict):
+ raise TypeError(f"*stats* must be a dict; got {type(stats)}")
+ stats.setdefault('iteration_count', 0)
+
+ # Uses a simple DFS to find back-edges.
+ # The new algorithm is faster than the the previous dominator based
+ # algorithm.
+ back_edges = set()
+ # stack: keeps track of the traversal path
+ stack = []
+ # succs_state: keep track of unvisited successors of a node
+ succs_state = {}
+ entry_point = self.entry_point()
+
+ checked = set()
+
+ def push_state(node):
+ stack.append(node)
+ succs_state[node] = [dest for dest in self._succs[node]]
+
+ push_state(entry_point)
+
+ # Keep track for iteration count for debugging
+ iter_ct = 0
+ while stack:
+ iter_ct += 1
+ tos = stack[-1]
+ tos_succs = succs_state[tos]
+ # Are there successors not checked?
+ if tos_succs:
+ # Check the next successor
+ cur_node = tos_succs.pop()
+ # Is it in our traversal path?
+ if cur_node in stack:
+ # Yes, it's a backedge
+ back_edges.add((tos, cur_node))
+ elif cur_node not in checked:
+ # Push
+ push_state(cur_node)
+ else:
+ # Checked all successors. Pop
+ stack.pop()
+ checked.add(tos)
+
+ if stats is not None:
+ stats['iteration_count'] += iter_ct
+ return back_edges
+
+ def _find_topo_order(self):
+ succs = self._succs
+ back_edges = self._back_edges
+ post_order = []
+ seen = set()
+
+ def _dfs_rec(node):
+ if node not in seen:
+ seen.add(node)
+ for dest in succs[node]:
+ if (node, dest) not in back_edges:
+ _dfs_rec(dest)
+ post_order.append(node)
+
+ _dfs_rec(self._entry_point)
+ post_order.reverse()
+ return post_order
+
+ def _find_descendents(self):
+ descs = {}
+ for node in reversed(self._topo_order):
+ descs[node] = node_descs = set()
+ for succ in self._succs[node]:
+ if (node, succ) not in self._back_edges:
+ node_descs.add(succ)
+ node_descs.update(descs[succ])
+ return descs
+
+ def _find_loops(self):
+ """
+ Find the loops defined by the graph's back edges.
+ """
+ bodies = {}
+ for src, dest in self._back_edges:
+ # The destination of the back edge is the loop header
+ header = dest
+ # Build up the loop body from the back edge's source node,
+ # up to the source header.
+ body = set([header])
+ queue = [src]
+ while queue:
+ n = queue.pop()
+ if n not in body:
+ body.add(n)
+ queue.extend(self._preds[n])
+ # There can be several back edges to a given loop header;
+ # if so, merge the resulting body fragments.
+ if header in bodies:
+ bodies[header].update(body)
+ else:
+ bodies[header] = body
+
+ # Create a Loop object for each header.
+ loops = {}
+ for header, body in bodies.items():
+ entries = set()
+ exits = set()
+ for n in body:
+ entries.update(self._preds[n] - body)
+ exits.update(self._succs[n] - body)
+ loop = Loop(header=header, body=body, entries=entries, exits=exits)
+ loops[header] = loop
+ return loops
+
+ def _find_in_loops(self):
+ loops = self._loops
+ # Compute the loops to which each node belongs.
+ in_loops = dict((n, []) for n in self._nodes)
+ # Sort loops from longest to shortest
+ # This ensures that outer loops will come before inner loops
+ for loop in sorted(loops.values(), key=lambda loop: len(loop.body)):
+ for n in loop.body:
+ in_loops[n].append(loop.header)
+ return in_loops
+
+ def _dump_adj_lists(self, file):
+ adj_lists = dict((src, sorted(list(dests)))
+ for src, dests in self._succs.items())
+ import pprint
+ pprint.pprint(adj_lists, stream=file)
+
+ def __eq__(self, other):
+ if not isinstance(other, CFGraph):
+ return NotImplemented
+
+ for x in ['_nodes', '_edge_data', '_entry_point', '_preds', '_succs']:
+ this = getattr(self, x, None)
+ that = getattr(other, x, None)
+ if this != that:
+ return False
+ return True
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+
+class ControlFlowAnalysis(object):
+ """
+ Attributes
+ ----------
+ - bytecode
+
+ - blocks
+
+ - blockseq
+
+ - doms: dict of set
+ Dominators
+
+ - backbone: set of block offsets
+ The set of block that is common to all possible code path.
+
+ """
+ def __init__(self, bytecode):
+ self.bytecode = bytecode
+ self.blocks = {}
+ self.liveblocks = {}
+ self.blockseq = []
+ self.doms = None
+ self.backbone = None
+ # Internal temp states
+ self._force_new_block = True
+ self._curblock = None
+ self._blockstack = []
+ self._loops = []
+ self._withs = []
+
+ def iterblocks(self):
+ """
+ Return all blocks in sequence of occurrence
+ """
+ for i in self.blockseq:
+ yield self.blocks[i]
+
+ def iterliveblocks(self):
+ """
+ Return all live blocks in sequence of occurrence
+ """
+ for i in self.blockseq:
+ if i in self.liveblocks:
+ yield self.blocks[i]
+
+ def incoming_blocks(self, block):
+ """
+ Yield (incoming block, number of stack pops) pairs for *block*.
+ """
+ for i, pops in block.incoming_jumps.items():
+ if i in self.liveblocks:
+ yield self.blocks[i], pops
+
+ def dump(self, file=None):
+ self.graph.dump(file=None)
+
+ def run(self):
+ for inst in self._iter_inst():
+ fname = "op_%s" % inst.opname
+ fn = getattr(self, fname, None)
+ if fn is not None:
+ fn(inst)
+ elif inst.is_jump:
+ # this catches e.g. try... except
+ l = Loc(self.bytecode.func_id.filename, inst.lineno)
+ if inst.opname in {"SETUP_FINALLY"}:
+ msg = "'try' block not supported until python3.7 or later"
+ else:
+ msg = "Use of unsupported opcode (%s) found" % inst.opname
+ raise UnsupportedError(msg, loc=l)
+ else:
+ # Non-jump instructions are ignored
+ pass # intentionally
+
+ # Close all blocks
+ for cur, nxt in zip(self.blockseq, self.blockseq[1:]):
+ blk = self.blocks[cur]
+ if not blk.outgoing_jumps and not blk.terminating:
+ blk.outgoing_jumps[nxt] = 0
+
+ graph = CFGraph()
+ for b in self.blocks:
+ graph.add_node(b)
+ for b in self.blocks.values():
+ for out, pops in b.outgoing_jumps.items():
+ graph.add_edge(b.offset, out, pops)
+ graph.set_entry_point(min(self.blocks))
+ graph.process()
+ self.graph = graph
+
+ # Fill incoming
+ for b in self.blocks.values():
+ for out, pops in b.outgoing_jumps.items():
+ self.blocks[out].incoming_jumps[b.offset] = pops
+
+ # Find liveblocks
+ self.liveblocks = dict((i, self.blocks[i])
+ for i in self.graph.nodes())
+
+ for lastblk in reversed(self.blockseq):
+ if lastblk in self.liveblocks:
+ break
+ else:
+ raise AssertionError("No live block that exits!?")
+
+ # Find backbone
+ backbone = self.graph.backbone()
+ # Filter out in loop blocks (Assuming no other cyclic control blocks)
+ # This is to unavoid variable defined in loops to be considered as
+ # function scope.
+ inloopblocks = set()
+
+ for b in self.blocks.keys():
+ if self.graph.in_loops(b):
+ inloopblocks.add(b)
+
+ self.backbone = backbone - inloopblocks
+
+ def jump(self, target, pops=0):
+ """
+ Register a jump (conditional or not) to *target* offset.
+ *pops* is the number of stack pops implied by the jump (default 0).
+ """
+ self._curblock.outgoing_jumps[target] = pops
+
+ def _iter_inst(self):
+ for inst in self.bytecode:
+ if self._use_new_block(inst):
+ self._guard_with_as(inst)
+ self._start_new_block(inst)
+ self._curblock.body.append(inst.offset)
+ yield inst
+
+ def _use_new_block(self, inst):
+ if inst.offset in self.bytecode.labels:
+ res = True
+ elif inst.opname in NEW_BLOCKERS:
+ res = True
+ else:
+ res = self._force_new_block
+
+ self._force_new_block = False
+ return res
+
+ def _start_new_block(self, inst):
+ self._curblock = CFBlock(inst.offset)
+ self.blocks[inst.offset] = self._curblock
+ self.blockseq.append(inst.offset)
+
+ def _guard_with_as(self, current_inst):
+ """Checks if the next instruction after a SETUP_WITH is something other
+ than a POP_TOP, if it is something else it'll be some sort of store
+ which is not supported (this corresponds to `with CTXMGR as VAR(S)`)."""
+ if current_inst.opname == "SETUP_WITH":
+ next_op = self.bytecode[current_inst.next].opname
+ if next_op != "POP_TOP":
+ msg = ("The 'with (context manager) as "
+ "(variable):' construct is not "
+ "supported.")
+ raise UnsupportedError(msg)
+
+ def op_SETUP_LOOP(self, inst):
+ end = inst.get_jump_target()
+ self._blockstack.append(end)
+ self._loops.append((inst.offset, end))
+ # TODO: Looplifting requires the loop entry be its own block.
+ # Forcing a new block here is the simplest solution for now.
+ # But, we should consider other less ad-hoc ways.
+ self.jump(inst.next)
+ self._force_new_block = True
+
+ def op_SETUP_WITH(self, inst):
+ end = inst.get_jump_target()
+ self._blockstack.append(end)
+ self._withs.append((inst.offset, end))
+ # TODO: WithLifting requires the loop entry be its own block.
+ # Forcing a new block here is the simplest solution for now.
+ # But, we should consider other less ad-hoc ways.
+ self.jump(inst.next)
+ self._force_new_block = True
+
+ def op_POP_BLOCK(self, inst):
+ self._blockstack.pop()
+
+ def op_FOR_ITER(self, inst):
+ self.jump(inst.get_jump_target())
+ self.jump(inst.next)
+ self._force_new_block = True
+
+ def _op_ABSOLUTE_JUMP_IF(self, inst):
+ self.jump(inst.get_jump_target())
+ self.jump(inst.next)
+ self._force_new_block = True
+
+ op_POP_JUMP_IF_FALSE = _op_ABSOLUTE_JUMP_IF
+ op_POP_JUMP_IF_TRUE = _op_ABSOLUTE_JUMP_IF
+ op_JUMP_IF_FALSE = _op_ABSOLUTE_JUMP_IF
+ op_JUMP_IF_TRUE = _op_ABSOLUTE_JUMP_IF
+
+ op_POP_JUMP_FORWARD_IF_FALSE = _op_ABSOLUTE_JUMP_IF
+ op_POP_JUMP_BACKWARD_IF_FALSE = _op_ABSOLUTE_JUMP_IF
+ op_POP_JUMP_FORWARD_IF_TRUE = _op_ABSOLUTE_JUMP_IF
+ op_POP_JUMP_BACKWARD_IF_TRUE = _op_ABSOLUTE_JUMP_IF
+
+ def _op_ABSOLUTE_JUMP_OR_POP(self, inst):
+ self.jump(inst.get_jump_target())
+ self.jump(inst.next, pops=1)
+ self._force_new_block = True
+
+ op_JUMP_IF_FALSE_OR_POP = _op_ABSOLUTE_JUMP_OR_POP
+ op_JUMP_IF_TRUE_OR_POP = _op_ABSOLUTE_JUMP_OR_POP
+
+ def op_JUMP_ABSOLUTE(self, inst):
+ self.jump(inst.get_jump_target())
+ self._force_new_block = True
+
+ def op_JUMP_FORWARD(self, inst):
+ self.jump(inst.get_jump_target())
+ self._force_new_block = True
+
+ op_JUMP_BACKWARD = op_JUMP_FORWARD
+
+ def op_RETURN_VALUE(self, inst):
+ self._curblock.terminating = True
+ self._force_new_block = True
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_RETURN_CONST(self, inst):
+ self._curblock.terminating = True
+ self._force_new_block = True
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_RAISE_VARARGS(self, inst):
+ self._curblock.terminating = True
+ self._force_new_block = True
+
+ def op_BREAK_LOOP(self, inst):
+ self.jump(self._blockstack[-1])
+ self._force_new_block = True
diff --git a/venv/lib/python3.10/site-packages/numba/core/cpu.py b/venv/lib/python3.10/site-packages/numba/core/cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d0d4b0dc6138ff146fb2c6f8a762477874279b0
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/cpu.py
@@ -0,0 +1,325 @@
+import platform
+
+import llvmlite.binding as ll
+from llvmlite import ir
+
+from numba import _dynfunc
+from numba.core.callwrapper import PyCallWrapper
+from numba.core.base import BaseContext
+from numba.core import (utils, types, config, cgutils, callconv, codegen,
+ externals, fastmathpass, intrinsics)
+from numba.core.options import TargetOptions, include_default_options
+from numba.core.runtime import rtsys
+from numba.core.compiler_lock import global_compiler_lock
+import numba.core.entrypoints
+# Re-export these options, they are used from the cpu module throughout the code
+# base.
+from numba.core.cpu_options import (ParallelOptions, # noqa F401
+ FastMathOptions, InlineOptions) # noqa F401
+from numba.np import ufunc_db
+
+# Keep those structures in sync with _dynfunc.c.
+
+
+class ClosureBody(cgutils.Structure):
+ _fields = [('env', types.pyobject)]
+
+
+class EnvBody(cgutils.Structure):
+ _fields = [
+ ('globals', types.pyobject),
+ ('consts', types.pyobject),
+ ]
+
+
+class CPUContext(BaseContext):
+ """
+ Changes BaseContext calling convention
+ """
+ allow_dynamic_globals = True
+
+ def __init__(self, typingctx, target='cpu'):
+ super().__init__(typingctx, target)
+
+ # Overrides
+ def create_module(self, name):
+ return self._internal_codegen._create_empty_module(name)
+
+ @global_compiler_lock
+ def init(self):
+ self.is32bit = (utils.MACHINE_BITS == 32)
+ self._internal_codegen = codegen.JITCPUCodegen("numba.exec")
+
+ # Add ARM ABI functions from libgcc_s
+ if platform.machine() == 'armv7l':
+ ll.load_library_permanently('libgcc_s.so.1')
+
+ # Map external C functions.
+ externals.c_math_functions.install(self)
+
+ def load_additional_registries(self):
+ # Only initialize the NRT once something is about to be compiled. The
+ # "initialized" state doesn't need to be threadsafe, there's a lock
+ # around the internal compilation and the rtsys.initialize call can be
+ # made multiple times, worse case init just gets called a bit more often
+ # than optimal.
+ rtsys.initialize(self)
+
+ # Add implementations that work via import
+ from numba.cpython import (builtins, charseq, enumimpl, # noqa F401
+ hashing, heapq, iterators, # noqa F401
+ listobj, numbers, rangeobj, # noqa F401
+ setobj, slicing, tupleobj, # noqa F401
+ unicode,) # noqa F401
+ from numba.core import optional, inline_closurecall # noqa F401
+ from numba.misc import gdb_hook, literal # noqa F401
+ from numba.np import linalg, arraymath, arrayobj # noqa F401
+ from numba.np.random import generator_core, generator_methods # noqa F401
+ from numba.np.polynomial import polynomial_core, polynomial_functions # noqa F401
+ from numba.typed import typeddict, dictimpl # noqa F401
+ from numba.typed import typedlist, listobject # noqa F401
+ from numba.experimental import jitclass, function_type # noqa F401
+ from numba.np import npdatetime # noqa F401
+
+ # Add target specific implementations
+ from numba.np import npyimpl
+ from numba.cpython import cmathimpl, mathimpl, printimpl, randomimpl
+ from numba.misc import cffiimpl
+ from numba.experimental.jitclass.base import ClassBuilder as \
+ jitclassimpl
+ self.install_registry(cmathimpl.registry)
+ self.install_registry(cffiimpl.registry)
+ self.install_registry(mathimpl.registry)
+ self.install_registry(npyimpl.registry)
+ self.install_registry(printimpl.registry)
+ self.install_registry(randomimpl.registry)
+ self.install_registry(jitclassimpl.class_impl_registry)
+
+ # load 3rd party extensions
+ numba.core.entrypoints.init_all()
+
+ # fix for #8940
+ from numba.np.unsafe import ndarray # noqa F401
+
+ @property
+ def target_data(self):
+ return self._internal_codegen.target_data
+
+ def with_aot_codegen(self, name, **aot_options):
+ aot_codegen = codegen.AOTCPUCodegen(name, **aot_options)
+ return self.subtarget(_internal_codegen=aot_codegen,
+ aot_mode=True)
+
+ def codegen(self):
+ return self._internal_codegen
+
+ @property
+ def call_conv(self):
+ return callconv.CPUCallConv(self)
+
+ def get_env_body(self, builder, envptr):
+ """
+ From the given *envptr* (a pointer to a _dynfunc.Environment object),
+ get a EnvBody allowing structured access to environment fields.
+ """
+ body_ptr = cgutils.pointer_add(
+ builder, envptr, _dynfunc._impl_info['offsetof_env_body'])
+ return EnvBody(self, builder, ref=body_ptr, cast_ref=True)
+
+ def get_env_manager(self, builder, return_pyobject=False):
+ envgv = self.declare_env_global(builder.module,
+ self.get_env_name(self.fndesc))
+ envarg = builder.load(envgv)
+ pyapi = self.get_python_api(builder)
+ pyapi.emit_environment_sentry(
+ envarg,
+ return_pyobject=return_pyobject,
+ debug_msg=self.fndesc.env_name,
+ )
+ env_body = self.get_env_body(builder, envarg)
+ return pyapi.get_env_manager(self.environment, env_body, envarg)
+
+ def get_generator_state(self, builder, genptr, return_type):
+ """
+ From the given *genptr* (a pointer to a _dynfunc.Generator object),
+ get a pointer to its state area.
+ """
+ return cgutils.pointer_add(
+ builder, genptr, _dynfunc._impl_info['offsetof_generator_state'],
+ return_type=return_type)
+
+ def build_list(self, builder, list_type, items):
+ """
+ Build a list from the Numba *list_type* and its initial *items*.
+ """
+ from numba.cpython import listobj
+ return listobj.build_list(self, builder, list_type, items)
+
+ def build_set(self, builder, set_type, items):
+ """
+ Build a set from the Numba *set_type* and its initial *items*.
+ """
+ from numba.cpython import setobj
+ return setobj.build_set(self, builder, set_type, items)
+
+ def build_map(self, builder, dict_type, item_types, items):
+ from numba.typed import dictobject
+
+ return dictobject.build_map(self, builder, dict_type, item_types, items)
+
+ def post_lowering(self, mod, library):
+ if self.fastmath:
+ fastmathpass.rewrite_module(mod, self.fastmath)
+
+ if self.is32bit:
+ # 32-bit machine needs to replace all 64-bit div/rem to avoid
+ # calls to compiler-rt
+ intrinsics.fix_divmod(mod)
+
+ library.add_linking_library(rtsys.library)
+
+ def create_cpython_wrapper(self, library, fndesc, env, call_helper,
+ release_gil=False):
+ wrapper_module = self.create_module("wrapper")
+ fnty = self.call_conv.get_function_type(fndesc.restype, fndesc.argtypes)
+ wrapper_callee = ir.Function(wrapper_module, fnty,
+ fndesc.llvm_func_name)
+ builder = PyCallWrapper(self, wrapper_module, wrapper_callee,
+ fndesc, env, call_helper=call_helper,
+ release_gil=release_gil)
+ builder.build()
+ library.add_ir_module(wrapper_module)
+
+ def create_cfunc_wrapper(self, library, fndesc, env, call_helper):
+ wrapper_module = self.create_module("cfunc_wrapper")
+ fnty = self.call_conv.get_function_type(fndesc.restype, fndesc.argtypes)
+ wrapper_callee = ir.Function(wrapper_module, fnty,
+ fndesc.llvm_func_name)
+
+ ll_argtypes = [self.get_value_type(ty) for ty in fndesc.argtypes]
+ ll_return_type = self.get_value_type(fndesc.restype)
+ wrapty = ir.FunctionType(ll_return_type, ll_argtypes)
+ wrapfn = ir.Function(wrapper_module, wrapty,
+ fndesc.llvm_cfunc_wrapper_name)
+ builder = ir.IRBuilder(wrapfn.append_basic_block('entry'))
+
+ status, out = self.call_conv.call_function(
+ builder, wrapper_callee, fndesc.restype, fndesc.argtypes,
+ wrapfn.args, attrs=('noinline',))
+
+ with builder.if_then(status.is_error, likely=False):
+ # If (and only if) an error occurred, acquire the GIL
+ # and use the interpreter to write out the exception.
+ pyapi = self.get_python_api(builder)
+ gil_state = pyapi.gil_ensure()
+ self.call_conv.raise_error(builder, pyapi, status)
+ cstr = self.insert_const_string(builder.module, repr(self))
+ strobj = pyapi.string_from_string(cstr)
+ pyapi.err_write_unraisable(strobj)
+ pyapi.decref(strobj)
+ pyapi.gil_release(gil_state)
+
+ builder.ret(out)
+ library.add_ir_module(wrapper_module)
+
+ def get_executable(self, library, fndesc, env):
+ """
+ Returns
+ -------
+ (cfunc, fnptr)
+
+ - cfunc
+ callable function (Can be None)
+ - fnptr
+ callable function address
+ - env
+ an execution environment (from _dynfunc)
+ """
+ # Code generation
+ fnptr = library.get_pointer_to_function(
+ fndesc.llvm_cpython_wrapper_name)
+
+ # Note: we avoid reusing the original docstring to avoid encoding
+ # issues on Python 2, see issue #1908
+ doc = "compiled wrapper for %r" % (fndesc.qualname,)
+ cfunc = _dynfunc.make_function(fndesc.lookup_module(),
+ fndesc.qualname.split('.')[-1],
+ doc, fnptr, env,
+ # objects to keepalive with the function
+ (library,)
+ )
+ library.codegen.set_env(self.get_env_name(fndesc), env)
+ return cfunc
+
+ def calc_array_sizeof(self, ndim):
+ '''
+ Calculate the size of an array struct on the CPU target
+ '''
+ aryty = types.Array(types.int32, ndim, 'A')
+ return self.get_abi_sizeof(self.get_value_type(aryty))
+
+ # Overrides
+ def get_ufunc_info(self, ufunc_key):
+ return ufunc_db.get_ufunc_info(ufunc_key)
+
+
+# ----------------------------------------------------------------------------
+# TargetOptions
+
+_options_mixin = include_default_options(
+ "nopython",
+ "forceobj",
+ "looplift",
+ "_nrt",
+ "debug",
+ "boundscheck",
+ "nogil",
+ "no_rewrites",
+ "no_cpython_wrapper",
+ "no_cfunc_wrapper",
+ "parallel",
+ "fastmath",
+ "error_model",
+ "inline",
+ "forceinline",
+ "_dbg_extend_lifetimes",
+ "_dbg_optnone",
+)
+
+
+class CPUTargetOptions(_options_mixin, TargetOptions):
+ def finalize(self, flags, options):
+ if not flags.is_set("enable_pyobject"):
+ flags.enable_pyobject = True
+
+ if not flags.is_set("enable_looplift"):
+ flags.enable_looplift = True
+
+ flags.inherit_if_not_set("nrt", default=True)
+
+ if not flags.is_set("debuginfo"):
+ flags.debuginfo = config.DEBUGINFO_DEFAULT
+
+ if not flags.is_set("dbg_extend_lifetimes"):
+ if flags.debuginfo:
+ # auto turn on extend-lifetimes if debuginfo is on and
+ # dbg_extend_lifetimes is not set
+ flags.dbg_extend_lifetimes = True
+ else:
+ # set flag using env-var config
+ flags.dbg_extend_lifetimes = config.EXTEND_VARIABLE_LIFETIMES
+
+ if not flags.is_set("boundscheck"):
+ flags.boundscheck = flags.debuginfo
+
+ flags.enable_pyobject_looplift = True
+
+ flags.inherit_if_not_set("fastmath")
+
+ flags.inherit_if_not_set("error_model", default="python")
+
+ flags.inherit_if_not_set("forceinline")
+
+ if flags.forceinline:
+ # forceinline turns off optnone, just like clang.
+ flags.dbg_optnone = False
diff --git a/venv/lib/python3.10/site-packages/numba/core/cpu_options.py b/venv/lib/python3.10/site-packages/numba/core/cpu_options.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2136c3194b44542072d69d9f5d8cd2736171886
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/cpu_options.py
@@ -0,0 +1,181 @@
+"""
+Defines CPU Options for use in the CPU target
+"""
+from abc import ABCMeta, abstractmethod
+
+
+class AbstractOptionValue(metaclass=ABCMeta):
+ """Abstract base class for custom option values.
+ """
+ @abstractmethod
+ def encode(self) -> str:
+ """Returns an encoding of the values
+ """
+ ...
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self.encode()})"
+
+
+class FastMathOptions(AbstractOptionValue):
+ """
+ Options for controlling fast math optimization.
+ """
+
+ def __init__(self, value):
+ # https://releases.llvm.org/7.0.0/docs/LangRef.html#fast-math-flags
+ valid_flags = {
+ 'fast',
+ 'nnan', 'ninf', 'nsz', 'arcp',
+ 'contract', 'afn', 'reassoc',
+ }
+
+ if isinstance(value, FastMathOptions):
+ self.flags = value.flags.copy()
+ elif value is True:
+ self.flags = {'fast'}
+ elif value is False:
+ self.flags = set()
+ elif isinstance(value, set):
+ invalid = value - valid_flags
+ if invalid:
+ raise ValueError("Unrecognized fastmath flags: %s" % invalid)
+ self.flags = value
+ elif isinstance(value, dict):
+ invalid = set(value.keys()) - valid_flags
+ if invalid:
+ raise ValueError("Unrecognized fastmath flags: %s" % invalid)
+ self.flags = {v for v, enable in value.items() if enable}
+ else:
+ msg = "Expected fastmath option(s) to be either a bool, dict or set"
+ raise ValueError(msg)
+
+ def __bool__(self):
+ return bool(self.flags)
+
+ __nonzero__ = __bool__
+
+ def encode(self) -> str:
+ return str(self.flags)
+
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self.flags == other.flags
+ return NotImplemented
+
+
+class ParallelOptions(AbstractOptionValue):
+ """
+ Options for controlling auto parallelization.
+ """
+ __slots__ = ("enabled", "comprehension", "reduction", "inplace_binop",
+ "setitem", "numpy", "stencil", "fusion", "prange")
+
+ def __init__(self, value):
+ if isinstance(value, bool):
+ self.enabled = value
+ self.comprehension = value
+ self.reduction = value
+ self.inplace_binop = value
+ self.setitem = value
+ self.numpy = value
+ self.stencil = value
+ self.fusion = value
+ self.prange = value
+ elif isinstance(value, dict):
+ self.enabled = True
+ self.comprehension = value.pop('comprehension', True)
+ self.reduction = value.pop('reduction', True)
+ self.inplace_binop = value.pop('inplace_binop', True)
+ self.setitem = value.pop('setitem', True)
+ self.numpy = value.pop('numpy', True)
+ self.stencil = value.pop('stencil', True)
+ self.fusion = value.pop('fusion', True)
+ self.prange = value.pop('prange', True)
+ if value:
+ msg = "Unrecognized parallel options: %s" % value.keys()
+ raise NameError(msg)
+ elif isinstance(value, ParallelOptions):
+ self.enabled = value.enabled
+ self.comprehension = value.comprehension
+ self.reduction = value.reduction
+ self.inplace_binop = value.inplace_binop
+ self.setitem = value.setitem
+ self.numpy = value.numpy
+ self.stencil = value.stencil
+ self.fusion = value.fusion
+ self.prange = value.prange
+ else:
+ msg = "Expect parallel option to be either a bool or a dict"
+ raise ValueError(msg)
+
+ def _get_values(self):
+ """Get values as dictionary.
+ """
+ return {k: getattr(self, k) for k in self.__slots__}
+
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._get_values() == other._get_values()
+ return NotImplemented
+
+ def encode(self) -> str:
+ return ", ".join(f"{k}={v}" for k, v in self._get_values().items())
+
+
+class InlineOptions(AbstractOptionValue):
+ """
+ Options for controlling inlining
+ """
+
+ def __init__(self, value):
+ ok = False
+ if isinstance(value, str):
+ if value in ('always', 'never'):
+ ok = True
+ else:
+ ok = hasattr(value, '__call__')
+
+ if ok:
+ self._inline = value
+ else:
+ msg = ("kwarg 'inline' must be one of the strings 'always' or "
+ "'never', or it can be a callable that returns True/False. "
+ "Found value %s" % value)
+ raise ValueError(msg)
+
+ @property
+ def is_never_inline(self):
+ """
+ True if never inline
+ """
+ return self._inline == 'never'
+
+ @property
+ def is_always_inline(self):
+ """
+ True if always inline
+ """
+ return self._inline == 'always'
+
+ @property
+ def has_cost_model(self):
+ """
+ True if a cost model is provided
+ """
+ return not (self.is_always_inline or self.is_never_inline)
+
+ @property
+ def value(self):
+ """
+ The raw value
+ """
+ return self._inline
+
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self.value == other.value
+ return NotImplemented
+
+ def encode(self) -> str:
+ return repr(self._inline)
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__init__.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f4f1eebd86acc01412cc2bcf634bd231540aac9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/__init__.py
@@ -0,0 +1,4 @@
+from .manager import DataModelManager
+from .packer import ArgPacker, DataPacker
+from .registry import register_default, default_manager, register
+from .models import PrimitiveModel, CompositeModel, StructModel # type: ignore
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..570e68aaa409a0611be6a4e4f416108dda0d9221
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/manager.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/manager.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eadc2352c30bfa7141147b5cc476a9b837bb135b
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/manager.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/models.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/models.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8790826d117ab96210c9cf8e6daa512484e15bf4
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/models.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/new_models.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/new_models.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b689d5ff84fe80d414d4bb005503905c0021fe05
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/new_models.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/old_models.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/old_models.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db338cddad4f0d6b16b5d31e3d677e15c51810c1
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/old_models.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/packer.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/packer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c572c2302edece8ec6cf468278e81d63d35ac60
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/packer.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/registry.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/registry.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13dc762a6d08a099d1d430e2f648253696c735ab
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/registry.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/testing.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/testing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..298b6289bea5c9585db5102d795ad1ccfbbe0da9
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/datamodel/__pycache__/testing.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/manager.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..95ec9e328000e7a31b7ae102d373a15e35bc81b2
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/manager.py
@@ -0,0 +1,68 @@
+import weakref
+from collections import ChainMap
+
+from numba.core import types
+
+
+class DataModelManager(object):
+ """Manages mapping of FE types to their corresponding data model
+ """
+
+ def __init__(self, handlers=None):
+ """
+ Parameters
+ -----------
+ handlers: Mapping[Type, DataModel] or None
+ Optionally provide the initial handlers mapping.
+ """
+ # { numba type class -> model factory }
+ self._handlers = handlers or {}
+ # { numba type instance -> model instance }
+ self._cache = weakref.WeakKeyDictionary()
+
+ def register(self, fetypecls, handler):
+ """Register the datamodel factory corresponding to a frontend-type class
+ """
+ assert issubclass(fetypecls, types.Type)
+ self._handlers[fetypecls] = handler
+
+ def lookup(self, fetype):
+ """Returns the corresponding datamodel given the frontend-type instance
+ """
+ try:
+ return self._cache[fetype]
+ except KeyError:
+ pass
+ handler = self._handlers[type(fetype)]
+ model = self._cache[fetype] = handler(self, fetype)
+ return model
+
+ def __getitem__(self, fetype):
+ """Shorthand for lookup()
+ """
+ return self.lookup(fetype)
+
+ def copy(self):
+ """
+ Make a copy of the manager.
+ Use this to inherit from the default data model and specialize it
+ for custom target.
+ """
+ return DataModelManager(self._handlers.copy())
+
+ def chain(self, other_manager):
+ """Create a new DataModelManager by chaining the handlers mapping of
+ `other_manager` with a fresh handlers mapping.
+
+ Any existing and new handlers inserted to `other_manager` will be
+ visible to the new manager. Any handlers inserted to the new manager
+ can override existing handlers in `other_manager` without actually
+ mutating `other_manager`.
+
+ Parameters
+ ----------
+ other_manager: DataModelManager
+ """
+ chained = ChainMap(self._handlers, other_manager._handlers)
+ return DataModelManager(chained)
+
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/models.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2328d9639a22f0273a07822aa9fc5205a3cb72b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/models.py
@@ -0,0 +1,12 @@
+import sys
+from numba.core.utils import _RedirectSubpackage
+from numba.core import config
+
+if config.USE_LEGACY_TYPE_SYSTEM: # type: ignore
+ sys.modules[__name__] = _RedirectSubpackage(
+ locals(), "numba.core.datamodel.old_models"
+ )
+else:
+ sys.modules[__name__] = _RedirectSubpackage(
+ locals(), "numba.core.datamodel.new_models"
+ )
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/new_models.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/new_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7c5c0f0792c65becf2e032b7d17dad37feb761f
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/new_models.py
@@ -0,0 +1,1390 @@
+from functools import partial
+from collections import deque
+
+from llvmlite import ir
+
+from numba.core.datamodel.registry import register_default
+from numba.core import types, cgutils
+from numba.np import numpy_support
+
+
+class DataModel(object):
+ """
+ DataModel describe how a FE type is represented in the LLVM IR at
+ different contexts.
+
+ Contexts are:
+
+ - value: representation inside function body. Maybe stored in stack.
+ The representation here are flexible.
+
+ - data: representation used when storing into containers (e.g. arrays).
+
+ - argument: representation used for function argument. All composite
+ types are unflattened into multiple primitive types.
+
+ - return: representation used for return argument.
+
+ Throughput the compiler pipeline, a LLVM value is usually passed around
+ in the "value" representation. All "as_" prefix function converts from
+ "value" representation. All "from_" prefix function converts to the
+ "value" representation.
+
+ """
+ def __init__(self, dmm, fe_type):
+ self._dmm = dmm
+ self._fe_type = fe_type
+
+ @property
+ def fe_type(self):
+ return self._fe_type
+
+ def get_value_type(self):
+ raise NotImplementedError(self)
+
+ def get_data_type(self):
+ return self.get_value_type()
+
+ def get_argument_type(self):
+ """Return a LLVM type or nested tuple of LLVM type
+ """
+ return self.get_value_type()
+
+ def get_return_type(self):
+ return self.get_value_type()
+
+ def as_data(self, builder, value):
+ raise NotImplementedError(self)
+
+ def as_argument(self, builder, value):
+ """
+ Takes one LLVM value
+ Return a LLVM value or nested tuple of LLVM value
+ """
+ raise NotImplementedError(self)
+
+ def as_return(self, builder, value):
+ raise NotImplementedError(self)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError(self)
+
+ def from_argument(self, builder, value):
+ """
+ Takes a LLVM value or nested tuple of LLVM value
+ Returns one LLVM value
+ """
+ raise NotImplementedError(self)
+
+ def from_return(self, builder, value):
+ raise NotImplementedError(self)
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ """
+ Load value from a pointer to data.
+ This is the default implementation, sufficient for most purposes.
+ """
+ return self.from_data(builder, builder.load(ptr, align=align))
+
+ def traverse(self, builder):
+ """
+ Traverse contained members.
+ Returns a iterable of contained (types, getters).
+ Each getter is a one-argument function accepting a LLVM value.
+ """
+ return []
+
+ def traverse_models(self):
+ """
+ Recursively list all models involved in this model.
+ """
+ return [self._dmm[t] for t in self.traverse_types()]
+
+ def traverse_types(self):
+ """
+ Recursively list all frontend types involved in this model.
+ """
+ types = [self._fe_type]
+ queue = deque([self])
+ while len(queue) > 0:
+ dm = queue.popleft()
+
+ for i_dm in dm.inner_models():
+ if i_dm._fe_type not in types:
+ queue.append(i_dm)
+ types.append(i_dm._fe_type)
+
+ return types
+
+ def inner_models(self):
+ """
+ List all *inner* models.
+ """
+ return []
+
+ def get_nrt_meminfo(self, builder, value):
+ """
+ Returns the MemInfo object or None if it is not tracked.
+ It is only defined for types.meminfo_pointer
+ """
+ return None
+
+ def has_nrt_meminfo(self):
+ return False
+
+ def contains_nrt_meminfo(self):
+ """
+ Recursively check all contained types for need for NRT meminfo.
+ """
+ return any(model.has_nrt_meminfo() for model in self.traverse_models())
+
+ def _compared_fields(self):
+ return (type(self), self._fe_type)
+
+ def __hash__(self):
+ return hash(tuple(self._compared_fields()))
+
+ def __eq__(self, other):
+ if type(self) is type(other):
+ return self._compared_fields() == other._compared_fields()
+ else:
+ return False
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+
+@register_default(types.Omitted)
+class OmittedArgDataModel(DataModel):
+ """
+ A data model for omitted arguments. Only the "argument" representation
+ is defined, other representations raise a NotImplementedError.
+ """
+ # Omitted arguments are using a dummy value type
+ def get_value_type(self):
+ return ir.LiteralStructType([])
+
+ # Omitted arguments don't produce any LLVM function argument.
+ def get_argument_type(self):
+ return ()
+
+ def as_argument(self, builder, val):
+ return ()
+
+ def from_argument(self, builder, val):
+ assert val == (), val
+ return None
+
+class PrimitiveModel(DataModel):
+ """A primitive type can be represented natively in the target in all
+ usage contexts.
+ """
+
+ def __init__(self, dmm, fe_type, be_type):
+ super(PrimitiveModel, self).__init__(dmm, fe_type)
+ self.be_type = be_type
+
+ def get_value_type(self):
+ return self.be_type
+
+ def as_data(self, builder, value):
+ return value
+
+ def as_argument(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_data(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+
+class ProxyModel(DataModel):
+ """
+ Helper class for models which delegate to another model.
+ """
+
+ def get_value_type(self):
+ return self._proxied_model.get_value_type()
+
+ def get_data_type(self):
+ return self._proxied_model.get_data_type()
+
+ def get_return_type(self):
+ return self._proxied_model.get_return_type()
+
+ def get_argument_type(self):
+ return self._proxied_model.get_argument_type()
+
+ def as_data(self, builder, value):
+ return self._proxied_model.as_data(builder, value)
+
+ def as_argument(self, builder, value):
+ return self._proxied_model.as_argument(builder, value)
+
+ def as_return(self, builder, value):
+ return self._proxied_model.as_return(builder, value)
+
+ def from_data(self, builder, value):
+ return self._proxied_model.from_data(builder, value)
+
+ def from_argument(self, builder, value):
+ return self._proxied_model.from_argument(builder, value)
+
+ def from_return(self, builder, value):
+ return self._proxied_model.from_return(builder, value)
+
+
+@register_default(types.EnumMember)
+@register_default(types.IntEnumMember)
+class EnumModel(ProxyModel):
+ """
+ Enum members are represented exactly like their values.
+ """
+ def __init__(self, dmm, fe_type):
+ super(EnumModel, self).__init__(dmm, fe_type)
+ self._proxied_model = dmm.lookup(fe_type.dtype)
+
+
+@register_default(types.Opaque)
+@register_default(types.PyObject)
+@register_default(types.RawPointer)
+@register_default(types.NoneType)
+@register_default(types.StringLiteral)
+@register_default(types.EllipsisType)
+@register_default(types.Function)
+@register_default(types.Type)
+@register_default(types.Object)
+@register_default(types.Module)
+@register_default(types.Phantom)
+@register_default(types.UndefVar)
+@register_default(types.ContextManager)
+@register_default(types.Dispatcher)
+@register_default(types.ObjModeDispatcher)
+@register_default(types.ExceptionClass)
+@register_default(types.Dummy)
+@register_default(types.ExceptionInstance)
+@register_default(types.ExternalFunction)
+@register_default(types.EnumClass)
+@register_default(types.IntEnumClass)
+@register_default(types.NumberClass)
+@register_default(types.TypeRef)
+@register_default(types.NamedTupleClass)
+@register_default(types.DType)
+@register_default(types.RecursiveCall)
+@register_default(types.MakeFunctionLiteral)
+@register_default(types.Poison)
+class OpaqueModel(PrimitiveModel):
+ """
+ Passed as opaque pointers
+ """
+ _ptr_type = ir.IntType(8).as_pointer()
+
+ def __init__(self, dmm, fe_type):
+ be_type = self._ptr_type
+ super(OpaqueModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.MemInfoPointer)
+class MemInfoModel(OpaqueModel):
+
+ def inner_models(self):
+ return [self._dmm.lookup(self._fe_type.dtype)]
+
+ def has_nrt_meminfo(self):
+ return True
+
+ def get_nrt_meminfo(self, builder, value):
+ return value
+
+
+@register_default(types.CPointer)
+class PointerModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ self._pointee_model = dmm.lookup(fe_type.dtype)
+ self._pointee_be_type = self._pointee_model.get_data_type()
+ be_type = self._pointee_be_type.as_pointer()
+ super(PointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.EphemeralPointer)
+class EphemeralPointerModel(PointerModel):
+
+ def get_data_type(self):
+ return self._pointee_be_type
+
+ def as_data(self, builder, value):
+ value = builder.load(value)
+ return self._pointee_model.as_data(builder, value)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError("use load_from_data_pointer() instead")
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.EphemeralArray)
+class EphemeralArrayModel(PointerModel):
+
+ def __init__(self, dmm, fe_type):
+ super(EphemeralArrayModel, self).__init__(dmm, fe_type)
+ self._data_type = ir.ArrayType(self._pointee_be_type,
+ self._fe_type.count)
+
+ def get_data_type(self):
+ return self._data_type
+
+ def as_data(self, builder, value):
+ values = [builder.load(cgutils.gep_inbounds(builder, value, i))
+ for i in range(self._fe_type.count)]
+ return cgutils.pack_array(builder, values)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError("use load_from_data_pointer() instead")
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.ExternalFunctionPointer)
+class ExternalFuncPointerModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ sig = fe_type.sig
+ # Since the function is non-Numba, there is no adaptation
+ # of arguments and return value, hence get_value_type().
+ retty = dmm.lookup(sig.return_type).get_value_type()
+ args = [dmm.lookup(t).get_value_type() for t in sig.args]
+ be_type = ir.PointerType(ir.FunctionType(retty, args))
+ super(ExternalFuncPointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.UniTuple)
+@register_default(types.NamedUniTuple)
+@register_default(types.StarArgUniTuple)
+class UniTupleModel(DataModel):
+ def __init__(self, dmm, fe_type):
+ super(UniTupleModel, self).__init__(dmm, fe_type)
+ self._elem_model = dmm.lookup(fe_type.dtype)
+ self._count = len(fe_type)
+ self._value_type = ir.ArrayType(self._elem_model.get_value_type(),
+ self._count)
+ self._data_type = ir.ArrayType(self._elem_model.get_data_type(),
+ self._count)
+
+ def get_value_type(self):
+ return self._value_type
+
+ def get_data_type(self):
+ return self._data_type
+
+ def get_return_type(self):
+ return self.get_value_type()
+
+ def get_argument_type(self):
+ return (self._elem_model.get_argument_type(),) * self._count
+
+ def as_argument(self, builder, value):
+ out = []
+ for i in range(self._count):
+ v = builder.extract_value(value, [i])
+ v = self._elem_model.as_argument(builder, v)
+ out.append(v)
+ return out
+
+ def from_argument(self, builder, value):
+ out = ir.Constant(self.get_value_type(), ir.Undefined)
+ for i, v in enumerate(value):
+ v = self._elem_model.from_argument(builder, v)
+ out = builder.insert_value(out, v, [i])
+ return out
+
+ def as_data(self, builder, value):
+ out = ir.Constant(self.get_data_type(), ir.Undefined)
+ for i in range(self._count):
+ val = builder.extract_value(value, [i])
+ dval = self._elem_model.as_data(builder, val)
+ out = builder.insert_value(out, dval, [i])
+ return out
+
+ def from_data(self, builder, value):
+ out = ir.Constant(self.get_value_type(), ir.Undefined)
+ for i in range(self._count):
+ val = builder.extract_value(value, [i])
+ dval = self._elem_model.from_data(builder, val)
+ out = builder.insert_value(out, dval, [i])
+ return out
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def traverse(self, builder):
+ def getter(i, value):
+ return builder.extract_value(value, i)
+ return [(self._fe_type.dtype, partial(getter, i))
+ for i in range(self._count)]
+
+ def inner_models(self):
+ return [self._elem_model]
+
+
+class CompositeModel(DataModel):
+ """Any model that is composed of multiple other models should subclass from
+ this.
+ """
+ pass
+
+
+class StructModel(CompositeModel):
+ _value_type = None
+ _data_type = None
+
+ def __init__(self, dmm, fe_type, members):
+ super(StructModel, self).__init__(dmm, fe_type)
+ if members:
+ self._fields, self._members = zip(*members)
+ else:
+ self._fields = self._members = ()
+ self._models = tuple([self._dmm.lookup(t) for t in self._members])
+
+ def get_member_fe_type(self, name):
+ """
+ StructModel-specific: get the Numba type of the field named *name*.
+ """
+ pos = self.get_field_position(name)
+ return self._members[pos]
+
+ def get_value_type(self):
+ if self._value_type is None:
+ self._value_type = ir.LiteralStructType([t.get_value_type()
+ for t in self._models])
+ return self._value_type
+
+ def get_data_type(self):
+ if self._data_type is None:
+ self._data_type = ir.LiteralStructType([t.get_data_type()
+ for t in self._models])
+ return self._data_type
+
+ def get_argument_type(self):
+ return tuple([t.get_argument_type() for t in self._models])
+
+ def get_return_type(self):
+ return self.get_data_type()
+
+ def _as(self, methname, builder, value):
+ extracted = []
+ for i, dm in enumerate(self._models):
+ extracted.append(getattr(dm, methname)(builder,
+ self.get(builder, value, i)))
+ return tuple(extracted)
+
+ def _from(self, methname, builder, value):
+ struct = ir.Constant(self.get_value_type(), ir.Undefined)
+
+ for i, (dm, val) in enumerate(zip(self._models, value)):
+ v = getattr(dm, methname)(builder, val)
+ struct = self.set(builder, struct, v, i)
+
+ return struct
+
+ def as_data(self, builder, value):
+ """
+ Converts the LLVM struct in `value` into a representation suited for
+ storing into arrays.
+
+ Note
+ ----
+ Current implementation rarely changes how types are represented for
+ "value" and "data". This is usually a pointless rebuild of the
+ immutable LLVM struct value. Luckily, LLVM optimization removes all
+ redundancy.
+
+ Sample usecase: Structures nested with pointers to other structures
+ that can be serialized into a flat representation when storing into
+ array.
+ """
+ elems = self._as("as_data", builder, value)
+ struct = ir.Constant(self.get_data_type(), ir.Undefined)
+ for i, el in enumerate(elems):
+ struct = builder.insert_value(struct, el, [i])
+ return struct
+
+ def from_data(self, builder, value):
+ """
+ Convert from "data" representation back into "value" representation.
+ Usually invoked when loading from array.
+
+ See notes in `as_data()`
+ """
+ vals = [builder.extract_value(value, [i])
+ for i in range(len(self._members))]
+ return self._from("from_data", builder, vals)
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ values = []
+ for i, model in enumerate(self._models):
+ elem_ptr = cgutils.gep_inbounds(builder, ptr, 0, i)
+ val = model.load_from_data_pointer(builder, elem_ptr, align)
+ values.append(val)
+
+ struct = ir.Constant(self.get_value_type(), ir.Undefined)
+ for i, val in enumerate(values):
+ struct = self.set(builder, struct, val, i)
+ return struct
+
+ def as_argument(self, builder, value):
+ return self._as("as_argument", builder, value)
+
+ def from_argument(self, builder, value):
+ return self._from("from_argument", builder, value)
+
+ def as_return(self, builder, value):
+ elems = self._as("as_data", builder, value)
+ struct = ir.Constant(self.get_data_type(), ir.Undefined)
+ for i, el in enumerate(elems):
+ struct = builder.insert_value(struct, el, [i])
+ return struct
+
+ def from_return(self, builder, value):
+ vals = [builder.extract_value(value, [i])
+ for i in range(len(self._members))]
+ return self._from("from_data", builder, vals)
+
+ def get(self, builder, val, pos):
+ """Get a field at the given position or the fieldname
+
+ Args
+ ----
+ builder:
+ LLVM IRBuilder
+ val:
+ value to be inserted
+ pos: int or str
+ field index or field name
+
+ Returns
+ -------
+ Extracted value
+ """
+ if isinstance(pos, str):
+ pos = self.get_field_position(pos)
+ return builder.extract_value(val, [pos],
+ name="extracted." + self._fields[pos])
+
+ def set(self, builder, stval, val, pos):
+ """Set a field at the given position or the fieldname
+
+ Args
+ ----
+ builder:
+ LLVM IRBuilder
+ stval:
+ LLVM struct value
+ val:
+ value to be inserted
+ pos: int or str
+ field index or field name
+
+ Returns
+ -------
+ A new LLVM struct with the value inserted
+ """
+ if isinstance(pos, str):
+ pos = self.get_field_position(pos)
+ return builder.insert_value(stval, val, [pos],
+ name="inserted." + self._fields[pos])
+
+ def get_field_position(self, field):
+ try:
+ return self._fields.index(field)
+ except ValueError:
+ raise KeyError("%s does not have a field named %r"
+ % (self.__class__.__name__, field))
+
+ @property
+ def field_count(self):
+ return len(self._fields)
+
+ def get_type(self, pos):
+ """Get the frontend type (numba type) of a field given the position
+ or the fieldname
+
+ Args
+ ----
+ pos: int or str
+ field index or field name
+ """
+ if isinstance(pos, str):
+ pos = self.get_field_position(pos)
+ return self._members[pos]
+
+ def get_model(self, pos):
+ """
+ Get the datamodel of a field given the position or the fieldname.
+
+ Args
+ ----
+ pos: int or str
+ field index or field name
+ """
+ return self._models[pos]
+
+ def traverse(self, builder):
+ def getter(k, value):
+ if value.type != self.get_value_type():
+ args = self.get_value_type(), value.type
+ raise TypeError("expecting {0} but got {1}".format(*args))
+ return self.get(builder, value, k)
+
+ return [(self.get_type(k), partial(getter, k)) for k in self._fields]
+
+ def inner_models(self):
+ return self._models
+
+
+@register_default(types.PythonBoolean)
+@register_default(types.PythonBooleanLiteral)
+@register_default(types.NumPyBoolean)
+@register_default(types.NumPyBooleanLiteral)
+@register_default(types.MachineBoolean)
+@register_default(types.MachineBooleanLiteral)
+class BooleanModel(DataModel):
+ _bit_type = ir.IntType(1)
+ _byte_type = ir.IntType(8)
+
+ def get_value_type(self):
+ return self._bit_type
+
+ def get_data_type(self):
+ return self._byte_type
+
+ def get_return_type(self):
+ return self.get_data_type()
+
+ def get_argument_type(self):
+ return self.get_data_type()
+
+ def as_data(self, builder, value):
+ return builder.zext(value, self.get_data_type())
+
+ def as_argument(self, builder, value):
+ return self.as_data(builder, value)
+
+ def as_return(self, builder, value):
+ return self.as_data(builder, value)
+
+ def from_data(self, builder, value):
+ ty = self.get_value_type()
+ resalloca = cgutils.alloca_once(builder, ty)
+ cond = builder.icmp_unsigned('==', value, value.type(0))
+ with builder.if_else(cond) as (then, otherwise):
+ with then:
+ builder.store(ty(0), resalloca)
+ with otherwise:
+ builder.store(ty(1), resalloca)
+ return builder.load(resalloca)
+
+ def from_argument(self, builder, value):
+ return self.from_data(builder, value)
+
+ def from_return(self, builder, value):
+ return self.from_data(builder, value)
+
+
+@register_default(types.PythonInteger)
+@register_default(types.PythonIntegerLiteral)
+@register_default(types.NumPyInteger)
+@register_default(types.NumPyIntegerLiteral)
+@register_default(types.MachineInteger)
+@register_default(types.MachineIntegerLiteral)
+class IntegerModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ be_type = ir.IntType(fe_type.bitwidth)
+ super(IntegerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.PythonFloat)
+@register_default(types.NumPyFloat)
+@register_default(types.MachineFloat)
+class FloatModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ be_type = ir.DoubleType()
+ super(FloatModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.PythonComplex)
+@register_default(types.NumPyComplex)
+@register_default(types.MachineComplex)
+class ComplexModel(StructModel):
+ _element_type = NotImplemented
+
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('real', fe_type.underlying_float),
+ ('imag', fe_type.underlying_float),
+ ]
+ super(ComplexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.LiteralList)
+@register_default(types.LiteralStrKeyDict)
+@register_default(types.Tuple)
+@register_default(types.NamedTuple)
+@register_default(types.StarArgTuple)
+class TupleModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('f' + str(i), t) for i, t in enumerate(fe_type)]
+ super(TupleModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UnionType)
+class UnionModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('tag', types.uintp),
+ # XXX: it should really be a MemInfoPointer(types.voidptr)
+ ('payload', types.Tuple.from_types(fe_type.types)),
+ ]
+ super(UnionModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Pair)
+class PairModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('first', fe_type.first_type),
+ ('second', fe_type.second_type)]
+ super(PairModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListPayload)
+class ListPayloadModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ # The fields are mutable but the payload is always manipulated
+ # by reference. This scheme allows mutations of an array to
+ # be seen by its iterators.
+ members = [
+ ('size', types.intp),
+ ('allocated', types.intp),
+ # This member is only used only for reflected lists
+ ('dirty', types.boolean),
+ # Actually an inlined var-sized array
+ ('data', fe_type.container.dtype),
+ ]
+ super(ListPayloadModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.List)
+class ListModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.ListPayload(fe_type)
+ members = [
+ # The meminfo data points to a ListPayload
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ # This member is only used only for reflected lists
+ ('parent', types.pyobject),
+ ]
+ super(ListModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListIter)
+class ListIterModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.ListPayload(fe_type.container)
+ members = [
+ # The meminfo data points to a ListPayload (shared with the
+ # original list object)
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ ('index', types.EphemeralPointer(types.intp)),
+ ]
+ super(ListIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetEntry)
+class SetEntryModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ dtype = fe_type.set_type.dtype
+ members = [
+ # -1 = empty, -2 = deleted
+ ('hash', types.intp),
+ ('key', dtype),
+ ]
+ super(SetEntryModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetPayload)
+class SetPayloadModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ entry_type = types.SetEntry(fe_type.container)
+ members = [
+ # Number of active + deleted entries
+ ('fill', types.intp),
+ # Number of active entries
+ ('used', types.intp),
+ # Allocated size - 1 (size being a power of 2)
+ ('mask', types.intp),
+ # Search finger
+ ('finger', types.intp),
+ # This member is only used only for reflected sets
+ ('dirty', types.boolean),
+ # Actually an inlined var-sized array
+ ('entries', entry_type),
+ ]
+ super(SetPayloadModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.Set)
+class SetModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.SetPayload(fe_type)
+ members = [
+ # The meminfo data points to a SetPayload
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ # This member is only used only for reflected sets
+ ('parent', types.pyobject),
+ ]
+ super(SetModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.SetIter)
+class SetIterModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.SetPayload(fe_type.container)
+ members = [
+ # The meminfo data points to a SetPayload (shared with the
+ # original set object)
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ # The index into the entries table
+ ('index', types.EphemeralPointer(types.intp)),
+ ]
+ super(SetIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Array)
+@register_default(types.Buffer)
+@register_default(types.ByteArray)
+@register_default(types.Bytes)
+@register_default(types.MemoryView)
+@register_default(types.PyArray)
+class ArrayModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ ndim = fe_type.ndim
+ members = [
+ ('meminfo', types.MemInfoPointer(fe_type.dtype)),
+ ('parent', types.pyobject),
+ ('nitems', types.intp),
+ ('itemsize', types.intp),
+ ('data', types.CPointer(fe_type.dtype)),
+ ('shape', types.UniTuple(types.intp, ndim)),
+ ('strides', types.UniTuple(types.intp, ndim)),
+
+ ]
+ super(ArrayModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ArrayFlags)
+class ArrayFlagsModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('parent', fe_type.array_type),
+ ]
+ super(ArrayFlagsModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NestedArray)
+class NestedArrayModel(ArrayModel):
+ def __init__(self, dmm, fe_type):
+ self._be_type = dmm.lookup(fe_type.dtype).get_data_type()
+ super(NestedArrayModel, self).__init__(dmm, fe_type)
+
+ def as_storage_type(self):
+ """Return the LLVM type representation for the storage of
+ the nestedarray.
+ """
+ ret = ir.ArrayType(self._be_type, self._fe_type.nitems)
+ return ret
+
+
+@register_default(types.Optional)
+class OptionalModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('data', fe_type.type),
+ ('valid', types.boolean),
+ ]
+ self._value_model = dmm.lookup(fe_type.type)
+ super(OptionalModel, self).__init__(dmm, fe_type, members)
+
+ def get_return_type(self):
+ return self._value_model.get_return_type()
+
+ def as_return(self, builder, value):
+ raise NotImplementedError
+
+ def from_return(self, builder, value):
+ return self._value_model.from_return(builder, value)
+
+ def traverse(self, builder):
+ def get_data(value):
+ valid = get_valid(value)
+ data = self.get(builder, value, "data")
+ return builder.select(valid, data, ir.Constant(data.type, None))
+ def get_valid(value):
+ return self.get(builder, value, "valid")
+
+ return [(self.get_type("data"), get_data),
+ (self.get_type("valid"), get_valid)]
+
+
+@register_default(types.Record)
+class RecordModel(CompositeModel):
+ def __init__(self, dmm, fe_type):
+ super(RecordModel, self).__init__(dmm, fe_type)
+ self._models = [self._dmm.lookup(t) for _, t in fe_type.members]
+ self._be_type = ir.ArrayType(ir.IntType(8), fe_type.size)
+ self._be_ptr_type = self._be_type.as_pointer()
+
+ def get_value_type(self):
+ """Passed around as reference to underlying data
+ """
+ return self._be_ptr_type
+
+ def get_argument_type(self):
+ return self._be_ptr_type
+
+ def get_return_type(self):
+ return self._be_ptr_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_data(self, builder, value):
+ return builder.load(value)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError("use load_from_data_pointer() instead")
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.UnicodeCharSeq)
+class UnicodeCharSeq(DataModel):
+ def __init__(self, dmm, fe_type):
+ super(UnicodeCharSeq, self).__init__(dmm, fe_type)
+ charty = ir.IntType(numpy_support.sizeof_unicode_char * 8)
+ self._be_type = ir.ArrayType(charty, fe_type.count)
+
+ def get_value_type(self):
+ return self._be_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_data(self, builder, value):
+ return value
+
+ def from_data(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+
+@register_default(types.CharSeq)
+class CharSeq(DataModel):
+ def __init__(self, dmm, fe_type):
+ super(CharSeq, self).__init__(dmm, fe_type)
+ charty = ir.IntType(8)
+ self._be_type = ir.ArrayType(charty, fe_type.count)
+
+ def get_value_type(self):
+ return self._be_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_data(self, builder, value):
+ return value
+
+ def from_data(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+
+class CContiguousFlatIter(StructModel):
+ def __init__(self, dmm, fe_type, need_indices):
+ assert fe_type.array_type.layout == 'C'
+ array_type = fe_type.array_type
+ dtype = array_type.dtype
+ ndim = array_type.ndim
+ members = [('array', array_type),
+ ('stride', types.intp),
+ ('index', types.EphemeralPointer(types.intp)),
+ ]
+ if need_indices:
+ # For ndenumerate()
+ members.append(('indices', types.EphemeralArray(types.intp, ndim)))
+ super(CContiguousFlatIter, self).__init__(dmm, fe_type, members)
+
+
+class FlatIter(StructModel):
+ def __init__(self, dmm, fe_type):
+ array_type = fe_type.array_type
+ dtype = array_type.dtype
+ ndim = array_type.ndim
+ members = [('array', array_type),
+ ('pointers', types.EphemeralArray(types.CPointer(dtype), ndim)),
+ ('indices', types.EphemeralArray(types.intp, ndim)),
+ ('exhausted', types.EphemeralPointer(types.boolean)),
+ ]
+ super(FlatIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UniTupleIter)
+class UniTupleIter(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('index', types.EphemeralPointer(types.intp)),
+ ('tuple', fe_type.container,)]
+ super(UniTupleIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.misc.SliceLiteral)
+@register_default(types.SliceType)
+class SliceModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('start', types.intp),
+ ('stop', types.intp),
+ ('step', types.intp),
+ ]
+ super(SliceModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NPDatetime)
+@register_default(types.NPTimedelta)
+class NPDatetimeModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ be_type = ir.IntType(64)
+ super(NPDatetimeModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.ArrayIterator)
+class ArrayIterator(StructModel):
+ def __init__(self, dmm, fe_type):
+ # We use an unsigned index to avoid the cost of negative index tests.
+ members = [('index', types.EphemeralPointer(types.uintp)),
+ ('array', fe_type.array_type)]
+ super(ArrayIterator, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.EnumerateType)
+class EnumerateType(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('count', types.EphemeralPointer(types.intp)),
+ ('iter', fe_type.source_type)]
+
+ super(EnumerateType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ZipType)
+class ZipType(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('iter%d' % i, source_type.iterator_type)
+ for i, source_type in enumerate(fe_type.source_types)]
+ super(ZipType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeIteratorType)
+class RangeIteratorType(StructModel):
+ def __init__(self, dmm, fe_type):
+ int_type = fe_type.yield_type
+ members = [('iter', types.EphemeralPointer(int_type)),
+ ('stop', int_type),
+ ('step', int_type),
+ ('count', types.EphemeralPointer(int_type))]
+ super(RangeIteratorType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Generator)
+class GeneratorModel(CompositeModel):
+ def __init__(self, dmm, fe_type):
+ super(GeneratorModel, self).__init__(dmm, fe_type)
+ # XXX Fold this in DataPacker?
+ self._arg_models = [self._dmm.lookup(t) for t in fe_type.arg_types
+ if not isinstance(t, types.Omitted)]
+ self._state_models = [self._dmm.lookup(t) for t in fe_type.state_types]
+
+ self._args_be_type = ir.LiteralStructType(
+ [t.get_data_type() for t in self._arg_models])
+ self._state_be_type = ir.LiteralStructType(
+ [t.get_data_type() for t in self._state_models])
+ # The whole generator closure
+ self._be_type = ir.LiteralStructType(
+ [self._dmm.lookup(types.int32).get_value_type(),
+ self._args_be_type, self._state_be_type])
+ self._be_ptr_type = self._be_type.as_pointer()
+
+ def get_value_type(self):
+ """
+ The generator closure is passed around as a reference.
+ """
+ return self._be_ptr_type
+
+ def get_argument_type(self):
+ return self._be_ptr_type
+
+ def get_return_type(self):
+ return self._be_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return self.as_data(builder, value)
+
+ def from_return(self, builder, value):
+ return self.from_data(builder, value)
+
+ def as_data(self, builder, value):
+ return builder.load(value)
+
+ def from_data(self, builder, value):
+ stack = cgutils.alloca_once(builder, value.type)
+ builder.store(value, stack)
+ return stack
+
+
+@register_default(types.ArrayCTypes)
+class ArrayCTypesModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ # ndim = fe_type.ndim
+ members = [('data', types.CPointer(fe_type.dtype)),
+ ('meminfo', types.MemInfoPointer(fe_type.dtype))]
+ super(ArrayCTypesModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeType)
+class RangeModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ int_type = fe_type.iterator_type.yield_type
+ members = [('start', int_type),
+ ('stop', int_type),
+ ('step', int_type)]
+ super(RangeModel, self).__init__(dmm, fe_type, members)
+
+
+# =============================================================================
+
+@register_default(types.NumpyNdIndexType)
+class NdIndexModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ ndim = fe_type.ndim
+ members = [('shape', types.UniTuple(types.intp, ndim)),
+ ('indices', types.EphemeralArray(types.intp, ndim)),
+ ('exhausted', types.EphemeralPointer(types.boolean)),
+ ]
+ super(NdIndexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NumpyFlatType)
+def handle_numpy_flat_type(dmm, ty):
+ if ty.array_type.layout == 'C':
+ return CContiguousFlatIter(dmm, ty, need_indices=False)
+ else:
+ return FlatIter(dmm, ty)
+
+@register_default(types.NumpyNdEnumerateType)
+def handle_numpy_ndenumerate_type(dmm, ty):
+ if ty.array_type.layout == 'C':
+ return CContiguousFlatIter(dmm, ty, need_indices=True)
+ else:
+ return FlatIter(dmm, ty)
+
+@register_default(types.BoundFunction)
+def handle_bound_function(dmm, ty):
+ # The same as the underlying type
+ return dmm[ty.this]
+
+
+@register_default(types.NumpyNdIterType)
+class NdIter(StructModel):
+ def __init__(self, dmm, fe_type):
+ array_types = fe_type.arrays
+ ndim = fe_type.ndim
+ shape_len = ndim if fe_type.need_shaped_indexing else 1
+ members = [('exhausted', types.EphemeralPointer(types.boolean)),
+ ('arrays', types.Tuple(array_types)),
+ # The iterator's main shape and indices
+ ('shape', types.UniTuple(types.intp, shape_len)),
+ ('indices', types.EphemeralArray(types.intp, shape_len)),
+ ]
+ # Indexing state for the various sub-iterators
+ # XXX use a tuple instead?
+ for i, sub in enumerate(fe_type.indexers):
+ kind, start_dim, end_dim, _ = sub
+ member_name = 'index%d' % i
+ if kind == 'flat':
+ # A single index into the flattened array
+ members.append((member_name, types.EphemeralPointer(types.intp)))
+ elif kind in ('scalar', 'indexed', '0d'):
+ # Nothing required
+ pass
+ else:
+ assert 0
+ # Slots holding values of the scalar args
+ # XXX use a tuple instead?
+ for i, ty in enumerate(fe_type.arrays):
+ if not isinstance(ty, types.Array):
+ member_name = 'scalar%d' % i
+ members.append((member_name, types.EphemeralPointer(ty)))
+
+ super(NdIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.DeferredType)
+class DeferredStructModel(CompositeModel):
+ def __init__(self, dmm, fe_type):
+ super(DeferredStructModel, self).__init__(dmm, fe_type)
+ self.typename = "deferred.{0}".format(id(fe_type))
+ self.actual_fe_type = fe_type.get()
+
+ def get_value_type(self):
+ return ir.global_context.get_identified_type(self.typename + '.value')
+
+ def get_data_type(self):
+ return ir.global_context.get_identified_type(self.typename + '.data')
+
+ def get_argument_type(self):
+ return self._actual_model.get_argument_type()
+
+ def as_argument(self, builder, value):
+ inner = self.get(builder, value)
+ return self._actual_model.as_argument(builder, inner)
+
+ def from_argument(self, builder, value):
+ res = self._actual_model.from_argument(builder, value)
+ return self.set(builder, self.make_uninitialized(), res)
+
+ def from_data(self, builder, value):
+ self._define()
+ elem = self.get(builder, value)
+ value = self._actual_model.from_data(builder, elem)
+ out = self.make_uninitialized()
+ return self.set(builder, out, value)
+
+ def as_data(self, builder, value):
+ self._define()
+ elem = self.get(builder, value)
+ value = self._actual_model.as_data(builder, elem)
+ out = self.make_uninitialized(kind='data')
+ return self.set(builder, out, value)
+
+ def from_return(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def get(self, builder, value):
+ return builder.extract_value(value, [0])
+
+ def set(self, builder, value, content):
+ return builder.insert_value(value, content, [0])
+
+ def make_uninitialized(self, kind='value'):
+ self._define()
+ if kind == 'value':
+ ty = self.get_value_type()
+ else:
+ ty = self.get_data_type()
+ return ir.Constant(ty, ir.Undefined)
+
+ def _define(self):
+ valty = self.get_value_type()
+ self._define_value_type(valty)
+ datty = self.get_data_type()
+ self._define_data_type(datty)
+
+ def _define_value_type(self, value_type):
+ if value_type.is_opaque:
+ value_type.set_body(self._actual_model.get_value_type())
+
+ def _define_data_type(self, data_type):
+ if data_type.is_opaque:
+ data_type.set_body(self._actual_model.get_data_type())
+
+ @property
+ def _actual_model(self):
+ return self._dmm.lookup(self.actual_fe_type)
+
+ def traverse(self, builder):
+ return [(self.actual_fe_type,
+ lambda value: builder.extract_value(value, [0]))]
+
+
+@register_default(types.StructRefPayload)
+class StructPayloadModel(StructModel):
+ """Model for the payload of a mutable struct
+ """
+ def __init__(self, dmm, fe_typ):
+ members = tuple(fe_typ.field_dict.items())
+ super().__init__(dmm, fe_typ, members)
+
+
+class StructRefModel(StructModel):
+ """Model for a mutable struct.
+ A reference to the payload
+ """
+ def __init__(self, dmm, fe_typ):
+ dtype = fe_typ.get_data_type()
+ members = [
+ ("meminfo", types.MemInfoPointer(dtype)),
+ ]
+ super().__init__(dmm, fe_typ, members)
+
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/old_models.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/old_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0837888d8fab9a97410d8c56e253b131660a8f64
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/old_models.py
@@ -0,0 +1,1385 @@
+from functools import partial
+from collections import deque
+
+from llvmlite import ir
+
+from numba.core.datamodel.registry import register_default
+from numba.core import types, cgutils
+from numba.np import numpy_support
+
+
+class DataModel(object):
+ """
+ DataModel describe how a FE type is represented in the LLVM IR at
+ different contexts.
+
+ Contexts are:
+
+ - value: representation inside function body. Maybe stored in stack.
+ The representation here are flexible.
+
+ - data: representation used when storing into containers (e.g. arrays).
+
+ - argument: representation used for function argument. All composite
+ types are unflattened into multiple primitive types.
+
+ - return: representation used for return argument.
+
+ Throughput the compiler pipeline, a LLVM value is usually passed around
+ in the "value" representation. All "as_" prefix function converts from
+ "value" representation. All "from_" prefix function converts to the
+ "value" representation.
+
+ """
+ def __init__(self, dmm, fe_type):
+ self._dmm = dmm
+ self._fe_type = fe_type
+
+ @property
+ def fe_type(self):
+ return self._fe_type
+
+ def get_value_type(self):
+ raise NotImplementedError(self)
+
+ def get_data_type(self):
+ return self.get_value_type()
+
+ def get_argument_type(self):
+ """Return a LLVM type or nested tuple of LLVM type
+ """
+ return self.get_value_type()
+
+ def get_return_type(self):
+ return self.get_value_type()
+
+ def as_data(self, builder, value):
+ raise NotImplementedError(self)
+
+ def as_argument(self, builder, value):
+ """
+ Takes one LLVM value
+ Return a LLVM value or nested tuple of LLVM value
+ """
+ raise NotImplementedError(self)
+
+ def as_return(self, builder, value):
+ raise NotImplementedError(self)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError(self)
+
+ def from_argument(self, builder, value):
+ """
+ Takes a LLVM value or nested tuple of LLVM value
+ Returns one LLVM value
+ """
+ raise NotImplementedError(self)
+
+ def from_return(self, builder, value):
+ raise NotImplementedError(self)
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ """
+ Load value from a pointer to data.
+ This is the default implementation, sufficient for most purposes.
+ """
+ return self.from_data(builder, builder.load(ptr, align=align))
+
+ def traverse(self, builder):
+ """
+ Traverse contained members.
+ Returns a iterable of contained (types, getters).
+ Each getter is a one-argument function accepting a LLVM value.
+ """
+ return []
+
+ def traverse_models(self):
+ """
+ Recursively list all models involved in this model.
+ """
+ return [self._dmm[t] for t in self.traverse_types()]
+
+ def traverse_types(self):
+ """
+ Recursively list all frontend types involved in this model.
+ """
+ types = [self._fe_type]
+ queue = deque([self])
+ while len(queue) > 0:
+ dm = queue.popleft()
+
+ for i_dm in dm.inner_models():
+ if i_dm._fe_type not in types:
+ queue.append(i_dm)
+ types.append(i_dm._fe_type)
+
+ return types
+
+ def inner_models(self):
+ """
+ List all *inner* models.
+ """
+ return []
+
+ def get_nrt_meminfo(self, builder, value):
+ """
+ Returns the MemInfo object or None if it is not tracked.
+ It is only defined for types.meminfo_pointer
+ """
+ return None
+
+ def has_nrt_meminfo(self):
+ return False
+
+ def contains_nrt_meminfo(self):
+ """
+ Recursively check all contained types for need for NRT meminfo.
+ """
+ return any(model.has_nrt_meminfo() for model in self.traverse_models())
+
+ def _compared_fields(self):
+ return (type(self), self._fe_type)
+
+ def __hash__(self):
+ return hash(tuple(self._compared_fields()))
+
+ def __eq__(self, other):
+ if type(self) is type(other):
+ return self._compared_fields() == other._compared_fields()
+ else:
+ return False
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+
+@register_default(types.Omitted)
+class OmittedArgDataModel(DataModel):
+ """
+ A data model for omitted arguments. Only the "argument" representation
+ is defined, other representations raise a NotImplementedError.
+ """
+ # Omitted arguments are using a dummy value type
+ def get_value_type(self):
+ return ir.LiteralStructType([])
+
+ # Omitted arguments don't produce any LLVM function argument.
+ def get_argument_type(self):
+ return ()
+
+ def as_argument(self, builder, val):
+ return ()
+
+ def from_argument(self, builder, val):
+ assert val == (), val
+ return None
+
+
+@register_default(types.Boolean)
+@register_default(types.BooleanLiteral)
+class BooleanModel(DataModel):
+ _bit_type = ir.IntType(1)
+ _byte_type = ir.IntType(8)
+
+ def get_value_type(self):
+ return self._bit_type
+
+ def get_data_type(self):
+ return self._byte_type
+
+ def get_return_type(self):
+ return self.get_data_type()
+
+ def get_argument_type(self):
+ return self.get_data_type()
+
+ def as_data(self, builder, value):
+ return builder.zext(value, self.get_data_type())
+
+ def as_argument(self, builder, value):
+ return self.as_data(builder, value)
+
+ def as_return(self, builder, value):
+ return self.as_data(builder, value)
+
+ def from_data(self, builder, value):
+ ty = self.get_value_type()
+ resalloca = cgutils.alloca_once(builder, ty)
+ cond = builder.icmp_unsigned('==', value, value.type(0))
+ with builder.if_else(cond) as (then, otherwise):
+ with then:
+ builder.store(ty(0), resalloca)
+ with otherwise:
+ builder.store(ty(1), resalloca)
+ return builder.load(resalloca)
+
+ def from_argument(self, builder, value):
+ return self.from_data(builder, value)
+
+ def from_return(self, builder, value):
+ return self.from_data(builder, value)
+
+
+class PrimitiveModel(DataModel):
+ """A primitive type can be represented natively in the target in all
+ usage contexts.
+ """
+
+ def __init__(self, dmm, fe_type, be_type):
+ super(PrimitiveModel, self).__init__(dmm, fe_type)
+ self.be_type = be_type
+
+ def get_value_type(self):
+ return self.be_type
+
+ def as_data(self, builder, value):
+ return value
+
+ def as_argument(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_data(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+
+class ProxyModel(DataModel):
+ """
+ Helper class for models which delegate to another model.
+ """
+
+ def get_value_type(self):
+ return self._proxied_model.get_value_type()
+
+ def get_data_type(self):
+ return self._proxied_model.get_data_type()
+
+ def get_return_type(self):
+ return self._proxied_model.get_return_type()
+
+ def get_argument_type(self):
+ return self._proxied_model.get_argument_type()
+
+ def as_data(self, builder, value):
+ return self._proxied_model.as_data(builder, value)
+
+ def as_argument(self, builder, value):
+ return self._proxied_model.as_argument(builder, value)
+
+ def as_return(self, builder, value):
+ return self._proxied_model.as_return(builder, value)
+
+ def from_data(self, builder, value):
+ return self._proxied_model.from_data(builder, value)
+
+ def from_argument(self, builder, value):
+ return self._proxied_model.from_argument(builder, value)
+
+ def from_return(self, builder, value):
+ return self._proxied_model.from_return(builder, value)
+
+
+@register_default(types.EnumMember)
+@register_default(types.IntEnumMember)
+class EnumModel(ProxyModel):
+ """
+ Enum members are represented exactly like their values.
+ """
+ def __init__(self, dmm, fe_type):
+ super(EnumModel, self).__init__(dmm, fe_type)
+ self._proxied_model = dmm.lookup(fe_type.dtype)
+
+
+@register_default(types.Opaque)
+@register_default(types.PyObject)
+@register_default(types.RawPointer)
+@register_default(types.NoneType)
+@register_default(types.StringLiteral)
+@register_default(types.EllipsisType)
+@register_default(types.Function)
+@register_default(types.Type)
+@register_default(types.Object)
+@register_default(types.Module)
+@register_default(types.Phantom)
+@register_default(types.UndefVar)
+@register_default(types.ContextManager)
+@register_default(types.Dispatcher)
+@register_default(types.ObjModeDispatcher)
+@register_default(types.ExceptionClass)
+@register_default(types.Dummy)
+@register_default(types.ExceptionInstance)
+@register_default(types.ExternalFunction)
+@register_default(types.EnumClass)
+@register_default(types.IntEnumClass)
+@register_default(types.NumberClass)
+@register_default(types.TypeRef)
+@register_default(types.NamedTupleClass)
+@register_default(types.DType)
+@register_default(types.RecursiveCall)
+@register_default(types.MakeFunctionLiteral)
+@register_default(types.Poison)
+class OpaqueModel(PrimitiveModel):
+ """
+ Passed as opaque pointers
+ """
+ _ptr_type = ir.IntType(8).as_pointer()
+
+ def __init__(self, dmm, fe_type):
+ be_type = self._ptr_type
+ super(OpaqueModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.MemInfoPointer)
+class MemInfoModel(OpaqueModel):
+
+ def inner_models(self):
+ return [self._dmm.lookup(self._fe_type.dtype)]
+
+ def has_nrt_meminfo(self):
+ return True
+
+ def get_nrt_meminfo(self, builder, value):
+ return value
+
+
+@register_default(types.Integer)
+@register_default(types.IntegerLiteral)
+class IntegerModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ be_type = ir.IntType(fe_type.bitwidth)
+ super(IntegerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.Float)
+class FloatModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ if fe_type == types.float32:
+ be_type = ir.FloatType()
+ elif fe_type == types.float64:
+ be_type = ir.DoubleType()
+ else:
+ raise NotImplementedError(fe_type)
+ super(FloatModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.CPointer)
+class PointerModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ self._pointee_model = dmm.lookup(fe_type.dtype)
+ self._pointee_be_type = self._pointee_model.get_data_type()
+ be_type = self._pointee_be_type.as_pointer()
+ super(PointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.EphemeralPointer)
+class EphemeralPointerModel(PointerModel):
+
+ def get_data_type(self):
+ return self._pointee_be_type
+
+ def as_data(self, builder, value):
+ value = builder.load(value)
+ return self._pointee_model.as_data(builder, value)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError("use load_from_data_pointer() instead")
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.EphemeralArray)
+class EphemeralArrayModel(PointerModel):
+
+ def __init__(self, dmm, fe_type):
+ super(EphemeralArrayModel, self).__init__(dmm, fe_type)
+ self._data_type = ir.ArrayType(self._pointee_be_type,
+ self._fe_type.count)
+
+ def get_data_type(self):
+ return self._data_type
+
+ def as_data(self, builder, value):
+ values = [builder.load(cgutils.gep_inbounds(builder, value, i))
+ for i in range(self._fe_type.count)]
+ return cgutils.pack_array(builder, values)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError("use load_from_data_pointer() instead")
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.ExternalFunctionPointer)
+class ExternalFuncPointerModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ sig = fe_type.sig
+ # Since the function is non-Numba, there is no adaptation
+ # of arguments and return value, hence get_value_type().
+ retty = dmm.lookup(sig.return_type).get_value_type()
+ args = [dmm.lookup(t).get_value_type() for t in sig.args]
+ be_type = ir.PointerType(ir.FunctionType(retty, args))
+ super(ExternalFuncPointerModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.UniTuple)
+@register_default(types.NamedUniTuple)
+@register_default(types.StarArgUniTuple)
+class UniTupleModel(DataModel):
+ def __init__(self, dmm, fe_type):
+ super(UniTupleModel, self).__init__(dmm, fe_type)
+ self._elem_model = dmm.lookup(fe_type.dtype)
+ self._count = len(fe_type)
+ self._value_type = ir.ArrayType(self._elem_model.get_value_type(),
+ self._count)
+ self._data_type = ir.ArrayType(self._elem_model.get_data_type(),
+ self._count)
+
+ def get_value_type(self):
+ return self._value_type
+
+ def get_data_type(self):
+ return self._data_type
+
+ def get_return_type(self):
+ return self.get_value_type()
+
+ def get_argument_type(self):
+ return (self._elem_model.get_argument_type(),) * self._count
+
+ def as_argument(self, builder, value):
+ out = []
+ for i in range(self._count):
+ v = builder.extract_value(value, [i])
+ v = self._elem_model.as_argument(builder, v)
+ out.append(v)
+ return out
+
+ def from_argument(self, builder, value):
+ out = ir.Constant(self.get_value_type(), ir.Undefined)
+ for i, v in enumerate(value):
+ v = self._elem_model.from_argument(builder, v)
+ out = builder.insert_value(out, v, [i])
+ return out
+
+ def as_data(self, builder, value):
+ out = ir.Constant(self.get_data_type(), ir.Undefined)
+ for i in range(self._count):
+ val = builder.extract_value(value, [i])
+ dval = self._elem_model.as_data(builder, val)
+ out = builder.insert_value(out, dval, [i])
+ return out
+
+ def from_data(self, builder, value):
+ out = ir.Constant(self.get_value_type(), ir.Undefined)
+ for i in range(self._count):
+ val = builder.extract_value(value, [i])
+ dval = self._elem_model.from_data(builder, val)
+ out = builder.insert_value(out, dval, [i])
+ return out
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def traverse(self, builder):
+ def getter(i, value):
+ return builder.extract_value(value, i)
+ return [(self._fe_type.dtype, partial(getter, i))
+ for i in range(self._count)]
+
+ def inner_models(self):
+ return [self._elem_model]
+
+
+class CompositeModel(DataModel):
+ """Any model that is composed of multiple other models should subclass from
+ this.
+ """
+ pass
+
+
+class StructModel(CompositeModel):
+ _value_type = None
+ _data_type = None
+
+ def __init__(self, dmm, fe_type, members):
+ super(StructModel, self).__init__(dmm, fe_type)
+ if members:
+ self._fields, self._members = zip(*members)
+ else:
+ self._fields = self._members = ()
+ self._models = tuple([self._dmm.lookup(t) for t in self._members])
+
+ def get_member_fe_type(self, name):
+ """
+ StructModel-specific: get the Numba type of the field named *name*.
+ """
+ pos = self.get_field_position(name)
+ return self._members[pos]
+
+ def get_value_type(self):
+ if self._value_type is None:
+ self._value_type = ir.LiteralStructType([t.get_value_type()
+ for t in self._models])
+ return self._value_type
+
+ def get_data_type(self):
+ if self._data_type is None:
+ self._data_type = ir.LiteralStructType([t.get_data_type()
+ for t in self._models])
+ return self._data_type
+
+ def get_argument_type(self):
+ return tuple([t.get_argument_type() for t in self._models])
+
+ def get_return_type(self):
+ return self.get_data_type()
+
+ def _as(self, methname, builder, value):
+ extracted = []
+ for i, dm in enumerate(self._models):
+ extracted.append(getattr(dm, methname)(builder,
+ self.get(builder, value, i)))
+ return tuple(extracted)
+
+ def _from(self, methname, builder, value):
+ struct = ir.Constant(self.get_value_type(), ir.Undefined)
+
+ for i, (dm, val) in enumerate(zip(self._models, value)):
+ v = getattr(dm, methname)(builder, val)
+ struct = self.set(builder, struct, v, i)
+
+ return struct
+
+ def as_data(self, builder, value):
+ """
+ Converts the LLVM struct in `value` into a representation suited for
+ storing into arrays.
+
+ Note
+ ----
+ Current implementation rarely changes how types are represented for
+ "value" and "data". This is usually a pointless rebuild of the
+ immutable LLVM struct value. Luckily, LLVM optimization removes all
+ redundancy.
+
+ Sample usecase: Structures nested with pointers to other structures
+ that can be serialized into a flat representation when storing into
+ array.
+ """
+ elems = self._as("as_data", builder, value)
+ struct = ir.Constant(self.get_data_type(), ir.Undefined)
+ for i, el in enumerate(elems):
+ struct = builder.insert_value(struct, el, [i])
+ return struct
+
+ def from_data(self, builder, value):
+ """
+ Convert from "data" representation back into "value" representation.
+ Usually invoked when loading from array.
+
+ See notes in `as_data()`
+ """
+ vals = [builder.extract_value(value, [i])
+ for i in range(len(self._members))]
+ return self._from("from_data", builder, vals)
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ values = []
+ for i, model in enumerate(self._models):
+ elem_ptr = cgutils.gep_inbounds(builder, ptr, 0, i)
+ val = model.load_from_data_pointer(builder, elem_ptr, align)
+ values.append(val)
+
+ struct = ir.Constant(self.get_value_type(), ir.Undefined)
+ for i, val in enumerate(values):
+ struct = self.set(builder, struct, val, i)
+ return struct
+
+ def as_argument(self, builder, value):
+ return self._as("as_argument", builder, value)
+
+ def from_argument(self, builder, value):
+ return self._from("from_argument", builder, value)
+
+ def as_return(self, builder, value):
+ elems = self._as("as_data", builder, value)
+ struct = ir.Constant(self.get_data_type(), ir.Undefined)
+ for i, el in enumerate(elems):
+ struct = builder.insert_value(struct, el, [i])
+ return struct
+
+ def from_return(self, builder, value):
+ vals = [builder.extract_value(value, [i])
+ for i in range(len(self._members))]
+ return self._from("from_data", builder, vals)
+
+ def get(self, builder, val, pos):
+ """Get a field at the given position or the fieldname
+
+ Args
+ ----
+ builder:
+ LLVM IRBuilder
+ val:
+ value to be inserted
+ pos: int or str
+ field index or field name
+
+ Returns
+ -------
+ Extracted value
+ """
+ if isinstance(pos, str):
+ pos = self.get_field_position(pos)
+ return builder.extract_value(val, [pos],
+ name="extracted." + self._fields[pos])
+
+ def set(self, builder, stval, val, pos):
+ """Set a field at the given position or the fieldname
+
+ Args
+ ----
+ builder:
+ LLVM IRBuilder
+ stval:
+ LLVM struct value
+ val:
+ value to be inserted
+ pos: int or str
+ field index or field name
+
+ Returns
+ -------
+ A new LLVM struct with the value inserted
+ """
+ if isinstance(pos, str):
+ pos = self.get_field_position(pos)
+ return builder.insert_value(stval, val, [pos],
+ name="inserted." + self._fields[pos])
+
+ def get_field_position(self, field):
+ try:
+ return self._fields.index(field)
+ except ValueError:
+ raise KeyError("%s does not have a field named %r"
+ % (self.__class__.__name__, field))
+
+ @property
+ def field_count(self):
+ return len(self._fields)
+
+ def get_type(self, pos):
+ """Get the frontend type (numba type) of a field given the position
+ or the fieldname
+
+ Args
+ ----
+ pos: int or str
+ field index or field name
+ """
+ if isinstance(pos, str):
+ pos = self.get_field_position(pos)
+ return self._members[pos]
+
+ def get_model(self, pos):
+ """
+ Get the datamodel of a field given the position or the fieldname.
+
+ Args
+ ----
+ pos: int or str
+ field index or field name
+ """
+ return self._models[pos]
+
+ def traverse(self, builder):
+ def getter(k, value):
+ if value.type != self.get_value_type():
+ args = self.get_value_type(), value.type
+ raise TypeError("expecting {0} but got {1}".format(*args))
+ return self.get(builder, value, k)
+
+ return [(self.get_type(k), partial(getter, k)) for k in self._fields]
+
+ def inner_models(self):
+ return self._models
+
+
+@register_default(types.Complex)
+class ComplexModel(StructModel):
+ _element_type = NotImplemented
+
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('real', fe_type.underlying_float),
+ ('imag', fe_type.underlying_float),
+ ]
+ super(ComplexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.LiteralList)
+@register_default(types.LiteralStrKeyDict)
+@register_default(types.Tuple)
+@register_default(types.NamedTuple)
+@register_default(types.StarArgTuple)
+class TupleModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('f' + str(i), t) for i, t in enumerate(fe_type)]
+ super(TupleModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UnionType)
+class UnionModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('tag', types.uintp),
+ # XXX: it should really be a MemInfoPointer(types.voidptr)
+ ('payload', types.Tuple.from_types(fe_type.types)),
+ ]
+ super(UnionModel, self).__init__(dmm, fe_type, members)
+
+
+
+@register_default(types.Pair)
+class PairModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('first', fe_type.first_type),
+ ('second', fe_type.second_type)]
+ super(PairModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListPayload)
+class ListPayloadModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ # The fields are mutable but the payload is always manipulated
+ # by reference. This scheme allows mutations of an array to
+ # be seen by its iterators.
+ members = [
+ ('size', types.intp),
+ ('allocated', types.intp),
+ # This member is only used only for reflected lists
+ ('dirty', types.boolean),
+ # Actually an inlined var-sized array
+ ('data', fe_type.container.dtype),
+ ]
+ super(ListPayloadModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.List)
+class ListModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.ListPayload(fe_type)
+ members = [
+ # The meminfo data points to a ListPayload
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ # This member is only used only for reflected lists
+ ('parent', types.pyobject),
+ ]
+ super(ListModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ListIter)
+class ListIterModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.ListPayload(fe_type.container)
+ members = [
+ # The meminfo data points to a ListPayload (shared with the
+ # original list object)
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ ('index', types.EphemeralPointer(types.intp)),
+ ]
+ super(ListIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetEntry)
+class SetEntryModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ dtype = fe_type.set_type.dtype
+ members = [
+ # -1 = empty, -2 = deleted
+ ('hash', types.intp),
+ ('key', dtype),
+ ]
+ super(SetEntryModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.SetPayload)
+class SetPayloadModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ entry_type = types.SetEntry(fe_type.container)
+ members = [
+ # Number of active + deleted entries
+ ('fill', types.intp),
+ # Number of active entries
+ ('used', types.intp),
+ # Allocated size - 1 (size being a power of 2)
+ ('mask', types.intp),
+ # Search finger
+ ('finger', types.intp),
+ # This member is only used only for reflected sets
+ ('dirty', types.boolean),
+ # Actually an inlined var-sized array
+ ('entries', entry_type),
+ ]
+ super(SetPayloadModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.Set)
+class SetModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.SetPayload(fe_type)
+ members = [
+ # The meminfo data points to a SetPayload
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ # This member is only used only for reflected sets
+ ('parent', types.pyobject),
+ ]
+ super(SetModel, self).__init__(dmm, fe_type, members)
+
+@register_default(types.SetIter)
+class SetIterModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ payload_type = types.SetPayload(fe_type.container)
+ members = [
+ # The meminfo data points to a SetPayload (shared with the
+ # original set object)
+ ('meminfo', types.MemInfoPointer(payload_type)),
+ # The index into the entries table
+ ('index', types.EphemeralPointer(types.intp)),
+ ]
+ super(SetIterModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Array)
+@register_default(types.Buffer)
+@register_default(types.ByteArray)
+@register_default(types.Bytes)
+@register_default(types.MemoryView)
+@register_default(types.PyArray)
+class ArrayModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ ndim = fe_type.ndim
+ members = [
+ ('meminfo', types.MemInfoPointer(fe_type.dtype)),
+ ('parent', types.pyobject),
+ ('nitems', types.intp),
+ ('itemsize', types.intp),
+ ('data', types.CPointer(fe_type.dtype)),
+ ('shape', types.UniTuple(types.intp, ndim)),
+ ('strides', types.UniTuple(types.intp, ndim)),
+
+ ]
+ super(ArrayModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ArrayFlags)
+class ArrayFlagsModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('parent', fe_type.array_type),
+ ]
+ super(ArrayFlagsModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NestedArray)
+class NestedArrayModel(ArrayModel):
+ def __init__(self, dmm, fe_type):
+ self._be_type = dmm.lookup(fe_type.dtype).get_data_type()
+ super(NestedArrayModel, self).__init__(dmm, fe_type)
+
+ def as_storage_type(self):
+ """Return the LLVM type representation for the storage of
+ the nestedarray.
+ """
+ ret = ir.ArrayType(self._be_type, self._fe_type.nitems)
+ return ret
+
+
+@register_default(types.Optional)
+class OptionalModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [
+ ('data', fe_type.type),
+ ('valid', types.boolean),
+ ]
+ self._value_model = dmm.lookup(fe_type.type)
+ super(OptionalModel, self).__init__(dmm, fe_type, members)
+
+ def get_return_type(self):
+ return self._value_model.get_return_type()
+
+ def as_return(self, builder, value):
+ raise NotImplementedError
+
+ def from_return(self, builder, value):
+ return self._value_model.from_return(builder, value)
+
+ def traverse(self, builder):
+ def get_data(value):
+ valid = get_valid(value)
+ data = self.get(builder, value, "data")
+ return builder.select(valid, data, ir.Constant(data.type, None))
+ def get_valid(value):
+ return self.get(builder, value, "valid")
+
+ return [(self.get_type("data"), get_data),
+ (self.get_type("valid"), get_valid)]
+
+
+@register_default(types.Record)
+class RecordModel(CompositeModel):
+ def __init__(self, dmm, fe_type):
+ super(RecordModel, self).__init__(dmm, fe_type)
+ self._models = [self._dmm.lookup(t) for _, t in fe_type.members]
+ self._be_type = ir.ArrayType(ir.IntType(8), fe_type.size)
+ self._be_ptr_type = self._be_type.as_pointer()
+
+ def get_value_type(self):
+ """Passed around as reference to underlying data
+ """
+ return self._be_ptr_type
+
+ def get_argument_type(self):
+ return self._be_ptr_type
+
+ def get_return_type(self):
+ return self._be_ptr_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_data(self, builder, value):
+ return builder.load(value)
+
+ def from_data(self, builder, value):
+ raise NotImplementedError("use load_from_data_pointer() instead")
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def load_from_data_pointer(self, builder, ptr, align=None):
+ return builder.bitcast(ptr, self.get_value_type())
+
+
+@register_default(types.UnicodeCharSeq)
+class UnicodeCharSeq(DataModel):
+ def __init__(self, dmm, fe_type):
+ super(UnicodeCharSeq, self).__init__(dmm, fe_type)
+ charty = ir.IntType(numpy_support.sizeof_unicode_char * 8)
+ self._be_type = ir.ArrayType(charty, fe_type.count)
+
+ def get_value_type(self):
+ return self._be_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_data(self, builder, value):
+ return value
+
+ def from_data(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+
+@register_default(types.CharSeq)
+class CharSeq(DataModel):
+ def __init__(self, dmm, fe_type):
+ super(CharSeq, self).__init__(dmm, fe_type)
+ charty = ir.IntType(8)
+ self._be_type = ir.ArrayType(charty, fe_type.count)
+
+ def get_value_type(self):
+ return self._be_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_data(self, builder, value):
+ return value
+
+ def from_data(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def from_return(self, builder, value):
+ return value
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+
+class CContiguousFlatIter(StructModel):
+ def __init__(self, dmm, fe_type, need_indices):
+ assert fe_type.array_type.layout == 'C'
+ array_type = fe_type.array_type
+ dtype = array_type.dtype
+ ndim = array_type.ndim
+ members = [('array', array_type),
+ ('stride', types.intp),
+ ('index', types.EphemeralPointer(types.intp)),
+ ]
+ if need_indices:
+ # For ndenumerate()
+ members.append(('indices', types.EphemeralArray(types.intp, ndim)))
+ super(CContiguousFlatIter, self).__init__(dmm, fe_type, members)
+
+
+class FlatIter(StructModel):
+ def __init__(self, dmm, fe_type):
+ array_type = fe_type.array_type
+ dtype = array_type.dtype
+ ndim = array_type.ndim
+ members = [('array', array_type),
+ ('pointers', types.EphemeralArray(types.CPointer(dtype), ndim)),
+ ('indices', types.EphemeralArray(types.intp, ndim)),
+ ('exhausted', types.EphemeralPointer(types.boolean)),
+ ]
+ super(FlatIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.UniTupleIter)
+class UniTupleIter(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('index', types.EphemeralPointer(types.intp)),
+ ('tuple', fe_type.container,)]
+ super(UniTupleIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.misc.SliceLiteral)
+@register_default(types.SliceType)
+class SliceModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('start', types.intp),
+ ('stop', types.intp),
+ ('step', types.intp),
+ ]
+ super(SliceModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NPDatetime)
+@register_default(types.NPTimedelta)
+class NPDatetimeModel(PrimitiveModel):
+ def __init__(self, dmm, fe_type):
+ be_type = ir.IntType(64)
+ super(NPDatetimeModel, self).__init__(dmm, fe_type, be_type)
+
+
+@register_default(types.ArrayIterator)
+class ArrayIterator(StructModel):
+ def __init__(self, dmm, fe_type):
+ # We use an unsigned index to avoid the cost of negative index tests.
+ members = [('index', types.EphemeralPointer(types.uintp)),
+ ('array', fe_type.array_type)]
+ super(ArrayIterator, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.EnumerateType)
+class EnumerateType(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('count', types.EphemeralPointer(types.intp)),
+ ('iter', fe_type.source_type)]
+
+ super(EnumerateType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.ZipType)
+class ZipType(StructModel):
+ def __init__(self, dmm, fe_type):
+ members = [('iter%d' % i, source_type.iterator_type)
+ for i, source_type in enumerate(fe_type.source_types)]
+ super(ZipType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeIteratorType)
+class RangeIteratorType(StructModel):
+ def __init__(self, dmm, fe_type):
+ int_type = fe_type.yield_type
+ members = [('iter', types.EphemeralPointer(int_type)),
+ ('stop', int_type),
+ ('step', int_type),
+ ('count', types.EphemeralPointer(int_type))]
+ super(RangeIteratorType, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.Generator)
+class GeneratorModel(CompositeModel):
+ def __init__(self, dmm, fe_type):
+ super(GeneratorModel, self).__init__(dmm, fe_type)
+ # XXX Fold this in DataPacker?
+ self._arg_models = [self._dmm.lookup(t) for t in fe_type.arg_types
+ if not isinstance(t, types.Omitted)]
+ self._state_models = [self._dmm.lookup(t) for t in fe_type.state_types]
+
+ self._args_be_type = ir.LiteralStructType(
+ [t.get_data_type() for t in self._arg_models])
+ self._state_be_type = ir.LiteralStructType(
+ [t.get_data_type() for t in self._state_models])
+ # The whole generator closure
+ self._be_type = ir.LiteralStructType(
+ [self._dmm.lookup(types.int32).get_value_type(),
+ self._args_be_type, self._state_be_type])
+ self._be_ptr_type = self._be_type.as_pointer()
+
+ def get_value_type(self):
+ """
+ The generator closure is passed around as a reference.
+ """
+ return self._be_ptr_type
+
+ def get_argument_type(self):
+ return self._be_ptr_type
+
+ def get_return_type(self):
+ return self._be_type
+
+ def get_data_type(self):
+ return self._be_type
+
+ def as_argument(self, builder, value):
+ return value
+
+ def from_argument(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return self.as_data(builder, value)
+
+ def from_return(self, builder, value):
+ return self.from_data(builder, value)
+
+ def as_data(self, builder, value):
+ return builder.load(value)
+
+ def from_data(self, builder, value):
+ stack = cgutils.alloca_once(builder, value.type)
+ builder.store(value, stack)
+ return stack
+
+
+@register_default(types.ArrayCTypes)
+class ArrayCTypesModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ # ndim = fe_type.ndim
+ members = [('data', types.CPointer(fe_type.dtype)),
+ ('meminfo', types.MemInfoPointer(fe_type.dtype))]
+ super(ArrayCTypesModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.RangeType)
+class RangeModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ int_type = fe_type.iterator_type.yield_type
+ members = [('start', int_type),
+ ('stop', int_type),
+ ('step', int_type)]
+ super(RangeModel, self).__init__(dmm, fe_type, members)
+
+
+# =============================================================================
+
+@register_default(types.NumpyNdIndexType)
+class NdIndexModel(StructModel):
+ def __init__(self, dmm, fe_type):
+ ndim = fe_type.ndim
+ members = [('shape', types.UniTuple(types.intp, ndim)),
+ ('indices', types.EphemeralArray(types.intp, ndim)),
+ ('exhausted', types.EphemeralPointer(types.boolean)),
+ ]
+ super(NdIndexModel, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.NumpyFlatType)
+def handle_numpy_flat_type(dmm, ty):
+ if ty.array_type.layout == 'C':
+ return CContiguousFlatIter(dmm, ty, need_indices=False)
+ else:
+ return FlatIter(dmm, ty)
+
+@register_default(types.NumpyNdEnumerateType)
+def handle_numpy_ndenumerate_type(dmm, ty):
+ if ty.array_type.layout == 'C':
+ return CContiguousFlatIter(dmm, ty, need_indices=True)
+ else:
+ return FlatIter(dmm, ty)
+
+@register_default(types.BoundFunction)
+def handle_bound_function(dmm, ty):
+ # The same as the underlying type
+ return dmm[ty.this]
+
+
+@register_default(types.NumpyNdIterType)
+class NdIter(StructModel):
+ def __init__(self, dmm, fe_type):
+ array_types = fe_type.arrays
+ ndim = fe_type.ndim
+ shape_len = ndim if fe_type.need_shaped_indexing else 1
+ members = [('exhausted', types.EphemeralPointer(types.boolean)),
+ ('arrays', types.Tuple(array_types)),
+ # The iterator's main shape and indices
+ ('shape', types.UniTuple(types.intp, shape_len)),
+ ('indices', types.EphemeralArray(types.intp, shape_len)),
+ ]
+ # Indexing state for the various sub-iterators
+ # XXX use a tuple instead?
+ for i, sub in enumerate(fe_type.indexers):
+ kind, start_dim, end_dim, _ = sub
+ member_name = 'index%d' % i
+ if kind == 'flat':
+ # A single index into the flattened array
+ members.append((member_name, types.EphemeralPointer(types.intp)))
+ elif kind in ('scalar', 'indexed', '0d'):
+ # Nothing required
+ pass
+ else:
+ assert 0
+ # Slots holding values of the scalar args
+ # XXX use a tuple instead?
+ for i, ty in enumerate(fe_type.arrays):
+ if not isinstance(ty, types.Array):
+ member_name = 'scalar%d' % i
+ members.append((member_name, types.EphemeralPointer(ty)))
+
+ super(NdIter, self).__init__(dmm, fe_type, members)
+
+
+@register_default(types.DeferredType)
+class DeferredStructModel(CompositeModel):
+ def __init__(self, dmm, fe_type):
+ super(DeferredStructModel, self).__init__(dmm, fe_type)
+ self.typename = "deferred.{0}".format(id(fe_type))
+ self.actual_fe_type = fe_type.get()
+
+ def get_value_type(self):
+ return ir.global_context.get_identified_type(self.typename + '.value')
+
+ def get_data_type(self):
+ return ir.global_context.get_identified_type(self.typename + '.data')
+
+ def get_argument_type(self):
+ return self._actual_model.get_argument_type()
+
+ def as_argument(self, builder, value):
+ inner = self.get(builder, value)
+ return self._actual_model.as_argument(builder, inner)
+
+ def from_argument(self, builder, value):
+ res = self._actual_model.from_argument(builder, value)
+ return self.set(builder, self.make_uninitialized(), res)
+
+ def from_data(self, builder, value):
+ self._define()
+ elem = self.get(builder, value)
+ value = self._actual_model.from_data(builder, elem)
+ out = self.make_uninitialized()
+ return self.set(builder, out, value)
+
+ def as_data(self, builder, value):
+ self._define()
+ elem = self.get(builder, value)
+ value = self._actual_model.as_data(builder, elem)
+ out = self.make_uninitialized(kind='data')
+ return self.set(builder, out, value)
+
+ def from_return(self, builder, value):
+ return value
+
+ def as_return(self, builder, value):
+ return value
+
+ def get(self, builder, value):
+ return builder.extract_value(value, [0])
+
+ def set(self, builder, value, content):
+ return builder.insert_value(value, content, [0])
+
+ def make_uninitialized(self, kind='value'):
+ self._define()
+ if kind == 'value':
+ ty = self.get_value_type()
+ else:
+ ty = self.get_data_type()
+ return ir.Constant(ty, ir.Undefined)
+
+ def _define(self):
+ valty = self.get_value_type()
+ self._define_value_type(valty)
+ datty = self.get_data_type()
+ self._define_data_type(datty)
+
+ def _define_value_type(self, value_type):
+ if value_type.is_opaque:
+ value_type.set_body(self._actual_model.get_value_type())
+
+ def _define_data_type(self, data_type):
+ if data_type.is_opaque:
+ data_type.set_body(self._actual_model.get_data_type())
+
+ @property
+ def _actual_model(self):
+ return self._dmm.lookup(self.actual_fe_type)
+
+ def traverse(self, builder):
+ return [(self.actual_fe_type,
+ lambda value: builder.extract_value(value, [0]))]
+
+
+@register_default(types.StructRefPayload)
+class StructPayloadModel(StructModel):
+ """Model for the payload of a mutable struct
+ """
+ def __init__(self, dmm, fe_typ):
+ members = tuple(fe_typ.field_dict.items())
+ super().__init__(dmm, fe_typ, members)
+
+
+class StructRefModel(StructModel):
+ """Model for a mutable struct.
+ A reference to the payload
+ """
+ def __init__(self, dmm, fe_typ):
+ dtype = fe_typ.get_data_type()
+ members = [
+ ("meminfo", types.MemInfoPointer(dtype)),
+ ]
+ super().__init__(dmm, fe_typ, members)
+
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/packer.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/packer.py
new file mode 100644
index 0000000000000000000000000000000000000000..9efc51449bc3699b67e2cef8035bbdb93c3dabde
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/packer.py
@@ -0,0 +1,213 @@
+from collections import deque
+
+from numba.core import types, cgutils
+
+
+
+class DataPacker(object):
+ """
+ A helper to pack a number of typed arguments into a data structure.
+ Omitted arguments (i.e. values with the type `Omitted`) are automatically
+ skipped.
+ """
+ # XXX should DataPacker be a model for a dedicated type?
+
+ def __init__(self, dmm, fe_types):
+ self._dmm = dmm
+ self._fe_types = fe_types
+ self._models = [dmm.lookup(ty) for ty in fe_types]
+
+ self._pack_map = []
+ self._be_types = []
+ for i, ty in enumerate(fe_types):
+ if not isinstance(ty, types.Omitted):
+ self._pack_map.append(i)
+ self._be_types.append(self._models[i].get_data_type())
+
+ def as_data(self, builder, values):
+ """
+ Return the given values packed as a data structure.
+ """
+ elems = [self._models[i].as_data(builder, values[i])
+ for i in self._pack_map]
+ return cgutils.make_anonymous_struct(builder, elems)
+
+ def _do_load(self, builder, ptr, formal_list=None):
+ res = []
+ for i, i_formal in enumerate(self._pack_map):
+ elem_ptr = cgutils.gep_inbounds(builder, ptr, 0, i)
+ val = self._models[i_formal].load_from_data_pointer(builder, elem_ptr)
+ if formal_list is None:
+ res.append((self._fe_types[i_formal], val))
+ else:
+ formal_list[i_formal] = val
+ return res
+
+ def load(self, builder, ptr):
+ """
+ Load the packed values and return a (type, value) tuples.
+ """
+ return self._do_load(builder, ptr)
+
+ def load_into(self, builder, ptr, formal_list):
+ """
+ Load the packed values into a sequence indexed by formal
+ argument number (skipping any Omitted position).
+ """
+ self._do_load(builder, ptr, formal_list)
+
+
+class ArgPacker(object):
+ """
+ Compute the position for each high-level typed argument.
+ It flattens every composite argument into primitive types.
+ It maintains a position map for unflattening the arguments.
+
+ Since struct (esp. nested struct) have specific ABI requirements (e.g.
+ alignment, pointer address-space, ...) in different architecture (e.g.
+ OpenCL, CUDA), flattening composite argument types simplifes the call
+ setup from the Python side. Functions are receiving simple primitive
+ types and there are only a handful of these.
+ """
+
+ def __init__(self, dmm, fe_args):
+ self._dmm = dmm
+ self._fe_args = fe_args
+ self._nargs = len(fe_args)
+
+ self._dm_args = []
+ argtys = []
+ for ty in fe_args:
+ dm = self._dmm.lookup(ty)
+ self._dm_args.append(dm)
+ argtys.append(dm.get_argument_type())
+ self._unflattener = _Unflattener(argtys)
+ self._be_args = list(_flatten(argtys))
+
+ def as_arguments(self, builder, values):
+ """Flatten all argument values
+ """
+ if len(values) != self._nargs:
+ raise TypeError("invalid number of args: expected %d, got %d"
+ % (self._nargs, len(values)))
+
+ if not values:
+ return ()
+
+ args = [dm.as_argument(builder, val)
+ for dm, val in zip(self._dm_args, values)
+ ]
+
+ args = tuple(_flatten(args))
+ return args
+
+ def from_arguments(self, builder, args):
+ """Unflatten all argument values
+ """
+
+ valtree = self._unflattener.unflatten(args)
+ values = [dm.from_argument(builder, val)
+ for dm, val in zip(self._dm_args, valtree)
+ ]
+
+ return values
+
+ def assign_names(self, args, names):
+ """Assign names for each flattened argument values.
+ """
+
+ valtree = self._unflattener.unflatten(args)
+ for aval, aname in zip(valtree, names):
+ self._assign_names(aval, aname)
+
+ def _assign_names(self, val_or_nested, name, depth=()):
+ if isinstance(val_or_nested, (tuple, list)):
+ for pos, aval in enumerate(val_or_nested):
+ self._assign_names(aval, name, depth=depth + (pos,))
+ else:
+ postfix = '.'.join(map(str, depth))
+ parts = [name, postfix]
+ val_or_nested.name = '.'.join(filter(bool, parts))
+
+ @property
+ def argument_types(self):
+ """Return a list of LLVM types that are results of flattening
+ composite types.
+ """
+ return tuple(ty for ty in self._be_args if ty != ())
+
+
+def _flatten(iterable):
+ """
+ Flatten nested iterable of (tuple, list).
+ """
+ def rec(iterable):
+ for i in iterable:
+ if isinstance(i, (tuple, list)):
+ for j in rec(i):
+ yield j
+ else:
+ yield i
+ return rec(iterable)
+
+
+_PUSH_LIST = 1
+_APPEND_NEXT_VALUE = 2
+_APPEND_EMPTY_TUPLE = 3
+_POP = 4
+
+class _Unflattener(object):
+ """
+ An object used to unflatten nested sequences after a given pattern
+ (an arbitrarily nested sequence).
+ The pattern shows the nested sequence shape desired when unflattening;
+ the values it contains are irrelevant.
+ """
+
+ def __init__(self, pattern):
+ self._code = self._build_unflatten_code(pattern)
+
+ def _build_unflatten_code(self, iterable):
+ """Build the unflatten opcode sequence for the given *iterable* structure
+ (an iterable of nested sequences).
+ """
+ code = []
+ def rec(iterable):
+ for i in iterable:
+ if isinstance(i, (tuple, list)):
+ if len(i) > 0:
+ code.append(_PUSH_LIST)
+ rec(i)
+ code.append(_POP)
+ else:
+ code.append(_APPEND_EMPTY_TUPLE)
+ else:
+ code.append(_APPEND_NEXT_VALUE)
+
+ rec(iterable)
+ return code
+
+ def unflatten(self, flatiter):
+ """Rebuild a nested tuple structure.
+ """
+ vals = deque(flatiter)
+
+ res = []
+ cur = res
+ stack = []
+ for op in self._code:
+ if op is _PUSH_LIST:
+ stack.append(cur)
+ cur.append([])
+ cur = cur[-1]
+ elif op is _APPEND_NEXT_VALUE:
+ cur.append(vals.popleft())
+ elif op is _APPEND_EMPTY_TUPLE:
+ cur.append(())
+ elif op is _POP:
+ cur = stack.pop()
+
+ assert not stack, stack
+ assert not vals, vals
+
+ return res
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/registry.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..18bdc475ef09727924b8159a0c9428f7c3abbee1
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/registry.py
@@ -0,0 +1,18 @@
+import functools
+from .manager import DataModelManager
+
+
+def register(dmm, typecls):
+ """Used as decorator to simplify datamodel registration.
+ Returns the object being decorated so that chaining is possible.
+ """
+ def wraps(fn):
+ dmm.register(typecls, fn)
+ return fn
+
+ return wraps
+
+
+default_manager = DataModelManager()
+
+register_default = functools.partial(register, default_manager)
diff --git a/venv/lib/python3.10/site-packages/numba/core/datamodel/testing.py b/venv/lib/python3.10/site-packages/numba/core/datamodel/testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2e8a2818b6111efc3979f28a7aa80eef4686a8e
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/datamodel/testing.py
@@ -0,0 +1,150 @@
+from llvmlite import ir
+from llvmlite import binding as ll
+
+from numba.core import datamodel
+import unittest
+
+
+class DataModelTester(unittest.TestCase):
+ """
+ Test the implementation of a DataModel for a frontend type.
+ """
+ fe_type = NotImplemented
+
+ def setUp(self):
+ self.module = ir.Module()
+ self.datamodel = datamodel.default_manager[self.fe_type]
+
+ def test_as_arg(self):
+ """
+ - Is as_arg() and from_arg() implemented?
+ - Are they the inverse of each other?
+ """
+ fnty = ir.FunctionType(ir.VoidType(), [])
+ function = ir.Function(self.module, fnty, name="test_as_arg")
+ builder = ir.IRBuilder()
+ builder.position_at_end(function.append_basic_block())
+
+ undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+ args = self.datamodel.as_argument(builder, undef_value)
+ self.assertIsNot(args, NotImplemented, "as_argument returned "
+ "NotImplementedError")
+
+ if isinstance(args, (tuple, list)):
+ def recur_tuplize(args, func=None):
+ for arg in args:
+ if isinstance(arg, (tuple, list)):
+ yield tuple(recur_tuplize(arg, func=func))
+ else:
+ if func is None:
+ yield arg
+ else:
+ yield func(arg)
+
+ argtypes = tuple(recur_tuplize(args, func=lambda x: x.type))
+ exptypes = tuple(recur_tuplize(
+ self.datamodel.get_argument_type()))
+ self.assertEqual(exptypes, argtypes)
+ else:
+ self.assertEqual(args.type,
+ self.datamodel.get_argument_type())
+
+ rev_value = self.datamodel.from_argument(builder, args)
+ self.assertEqual(rev_value.type, self.datamodel.get_value_type())
+
+ builder.ret_void() # end function
+
+ # Ensure valid LLVM generation
+ materialized = ll.parse_assembly(str(self.module))
+ str(materialized)
+
+ def test_as_return(self):
+ """
+ - Is as_return() and from_return() implemented?
+ - Are they the inverse of each other?
+ """
+ fnty = ir.FunctionType(ir.VoidType(), [])
+ function = ir.Function(self.module, fnty, name="test_as_return")
+ builder = ir.IRBuilder()
+ builder.position_at_end(function.append_basic_block())
+
+ undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+ ret = self.datamodel.as_return(builder, undef_value)
+ self.assertIsNot(ret, NotImplemented, "as_return returned "
+ "NotImplementedError")
+
+ self.assertEqual(ret.type, self.datamodel.get_return_type())
+
+ rev_value = self.datamodel.from_return(builder, ret)
+ self.assertEqual(rev_value.type, self.datamodel.get_value_type())
+
+ builder.ret_void() # end function
+
+ # Ensure valid LLVM generation
+ materialized = ll.parse_assembly(str(self.module))
+ str(materialized)
+
+
+class SupportAsDataMixin(object):
+ """Test as_data() and from_data()
+ """
+ # XXX test load_from_data_pointer() as well
+
+ def test_as_data(self):
+ fnty = ir.FunctionType(ir.VoidType(), [])
+ function = ir.Function(self.module, fnty, name="test_as_data")
+ builder = ir.IRBuilder()
+ builder.position_at_end(function.append_basic_block())
+
+ undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+ data = self.datamodel.as_data(builder, undef_value)
+ self.assertIsNot(data, NotImplemented,
+ "as_data returned NotImplemented")
+
+ self.assertEqual(data.type, self.datamodel.get_data_type())
+
+ rev_value = self.datamodel.from_data(builder, data)
+ self.assertEqual(rev_value.type,
+ self.datamodel.get_value_type())
+
+ builder.ret_void() # end function
+
+ # Ensure valid LLVM generation
+ materialized = ll.parse_assembly(str(self.module))
+ str(materialized)
+
+
+class NotSupportAsDataMixin(object):
+ """Ensure as_data() and from_data() raise NotImplementedError.
+ """
+
+ def test_as_data_not_supported(self):
+ fnty = ir.FunctionType(ir.VoidType(), [])
+ function = ir.Function(self.module, fnty, name="test_as_data")
+ builder = ir.IRBuilder()
+ builder.position_at_end(function.append_basic_block())
+
+ undef_value = ir.Constant(self.datamodel.get_value_type(), None)
+ with self.assertRaises(NotImplementedError):
+ data = self.datamodel.as_data(builder, undef_value)
+ with self.assertRaises(NotImplementedError):
+ rev_data = self.datamodel.from_data(builder, undef_value)
+
+
+class DataModelTester_SupportAsDataMixin(DataModelTester,
+ SupportAsDataMixin):
+ pass
+
+
+class DataModelTester_NotSupportAsDataMixin(DataModelTester,
+ NotSupportAsDataMixin):
+ pass
+
+
+def test_factory(support_as_data=True):
+ """A helper for returning a unittest TestCase for testing
+ """
+ if support_as_data:
+ return DataModelTester_SupportAsDataMixin
+ else:
+ return DataModelTester_NotSupportAsDataMixin
diff --git a/venv/lib/python3.10/site-packages/numba/core/debuginfo.py b/venv/lib/python3.10/site-packages/numba/core/debuginfo.py
new file mode 100644
index 0000000000000000000000000000000000000000..7970fc8e626995814def48ffe524e133e11477d6
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/debuginfo.py
@@ -0,0 +1,456 @@
+"""
+Implements helpers to build LLVM debuginfo.
+"""
+
+
+import abc
+import os.path
+from contextlib import contextmanager
+
+from llvmlite import ir
+from numba.core import cgutils, types
+from numba.core.datamodel.models import ComplexModel, UniTupleModel
+from numba.core import config
+
+
+@contextmanager
+def suspend_emission(builder):
+ """Suspends the emission of debug_metadata for the duration of the context
+ managed block."""
+ ref = builder.debug_metadata
+ builder.debug_metadata = None
+ try:
+ yield
+ finally:
+ builder.debug_metadata = ref
+
+
+class AbstractDIBuilder(metaclass=abc.ABCMeta):
+ @abc.abstractmethod
+ def mark_variable(self, builder, allocavalue, name, lltype, size, line,
+ datamodel=None, argidx=None):
+ """Emit debug info for the variable.
+ """
+ pass
+
+ @abc.abstractmethod
+ def mark_location(self, builder, line):
+ """Emit source location information to the given IRBuilder.
+ """
+ pass
+
+ @abc.abstractmethod
+ def mark_subprogram(self, function, qualname, argnames, argtypes, line):
+ """Emit source location information for the given function.
+ """
+ pass
+
+ @abc.abstractmethod
+ def initialize(self):
+ """Initialize the debug info. An opportunity for the debuginfo to
+ prepare any necessary data structures.
+ """
+
+ @abc.abstractmethod
+ def finalize(self):
+ """Finalize the debuginfo by emitting all necessary metadata.
+ """
+ pass
+
+
+class DummyDIBuilder(AbstractDIBuilder):
+
+ def __init__(self, module, filepath, cgctx, directives_only):
+ pass
+
+ def mark_variable(self, builder, allocavalue, name, lltype, size, line,
+ datamodel=None, argidx=None):
+ pass
+
+ def mark_location(self, builder, line):
+ pass
+
+ def mark_subprogram(self, function, qualname, argnames, argtypes, line):
+ pass
+
+ def initialize(self):
+ pass
+
+ def finalize(self):
+ pass
+
+
+_BYTE_SIZE = 8
+
+
+class DIBuilder(AbstractDIBuilder):
+ DWARF_VERSION = 4
+ DEBUG_INFO_VERSION = 3
+ DBG_CU_NAME = 'llvm.dbg.cu'
+ _DEBUG = False
+
+ def __init__(self, module, filepath, cgctx, directives_only):
+ self.module = module
+ self.filepath = os.path.abspath(filepath)
+ self.difile = self._di_file()
+ self.subprograms = []
+ self.cgctx = cgctx
+
+ if directives_only:
+ self.emission_kind = 'DebugDirectivesOnly'
+ else:
+ self.emission_kind = 'FullDebug'
+
+ self.initialize()
+
+ def initialize(self):
+ # Create the compile unit now because it is referenced when
+ # constructing subprograms
+ self.dicompileunit = self._di_compile_unit()
+
+ def _var_type(self, lltype, size, datamodel=None):
+ if self._DEBUG:
+ print("-->", lltype, size, datamodel,
+ getattr(datamodel, 'fe_type', 'NO FE TYPE'))
+ m = self.module
+ bitsize = _BYTE_SIZE * size
+
+ int_type = ir.IntType,
+ real_type = ir.FloatType, ir.DoubleType
+ # For simple numeric types, choose the closest encoding.
+ # We treat all integers as unsigned when there's no known datamodel.
+ if isinstance(lltype, int_type + real_type):
+ if datamodel is None:
+ # This is probably something like an `i8*` member of a struct
+ name = str(lltype)
+ if isinstance(lltype, int_type):
+ ditok = 'DW_ATE_unsigned'
+ else:
+ ditok = 'DW_ATE_float'
+ else:
+ # This is probably a known int/float scalar type
+ name = str(datamodel.fe_type)
+ if isinstance(datamodel.fe_type, types.Integer):
+ if datamodel.fe_type.signed:
+ ditok = 'DW_ATE_signed'
+ else:
+ ditok = 'DW_ATE_unsigned'
+ else:
+ ditok = 'DW_ATE_float'
+ mdtype = m.add_debug_info('DIBasicType', {
+ 'name': name,
+ 'size': bitsize,
+ 'encoding': ir.DIToken(ditok),
+ })
+ elif isinstance(datamodel, ComplexModel):
+ # TODO: Is there a better way of determining "this is a complex
+ # number"?
+ #
+ # NOTE: Commented below is the way to generate the metadata for a
+ # C99 complex type that's directly supported by DWARF. Numba however
+ # generates a struct with real/imag cf. CPython to give a more
+ # pythonic feel to inspection.
+ #
+ # mdtype = m.add_debug_info('DIBasicType', {
+ # 'name': f"{datamodel.fe_type} ({str(lltype)})",
+ # 'size': bitsize,
+ # 'encoding': ir.DIToken('DW_ATE_complex_float'),
+ #})
+ meta = []
+ offset = 0
+ for ix, name in enumerate(('real', 'imag')):
+ component = lltype.elements[ix]
+ component_size = self.cgctx.get_abi_sizeof(component)
+ component_basetype = m.add_debug_info('DIBasicType', {
+ 'name': str(component),
+ 'size': _BYTE_SIZE * component_size, # bits
+ 'encoding': ir.DIToken('DW_ATE_float'),
+ })
+ derived_type = m.add_debug_info('DIDerivedType', {
+ 'tag': ir.DIToken('DW_TAG_member'),
+ 'name': name,
+ 'baseType': component_basetype,
+ 'size': _BYTE_SIZE * component_size, # DW_TAG_member size is in bits
+ 'offset': offset,
+ })
+ meta.append(derived_type)
+ offset += (_BYTE_SIZE * component_size) # offset is in bits
+ mdtype = m.add_debug_info('DICompositeType', {
+ 'tag': ir.DIToken('DW_TAG_structure_type'),
+ 'name': f"{datamodel.fe_type} ({str(lltype)})",
+ 'identifier': str(lltype),
+ 'elements': m.add_metadata(meta),
+ 'size': offset,
+ }, is_distinct=True)
+ elif isinstance(datamodel, UniTupleModel):
+ element = lltype.element
+ el_size = self.cgctx.get_abi_sizeof(element)
+ basetype = self._var_type(element, el_size)
+ name = f"{datamodel.fe_type} ({str(lltype)})"
+ count = size // el_size
+ mdrange = m.add_debug_info('DISubrange', {
+ 'count': count,
+ })
+ mdtype = m.add_debug_info('DICompositeType', {
+ 'tag': ir.DIToken('DW_TAG_array_type'),
+ 'baseType': basetype,
+ 'name': name,
+ 'size': bitsize,
+ 'identifier': str(lltype),
+ 'elements': m.add_metadata([mdrange]),
+ })
+ elif isinstance(lltype, ir.PointerType):
+ model = getattr(datamodel, '_pointee_model', None)
+ basetype = self._var_type(lltype.pointee,
+ self.cgctx.get_abi_sizeof(lltype.pointee),
+ model)
+ mdtype = m.add_debug_info('DIDerivedType', {
+ 'tag': ir.DIToken('DW_TAG_pointer_type'),
+ 'baseType': basetype,
+ 'size': _BYTE_SIZE * self.cgctx.get_abi_sizeof(lltype)
+ })
+ elif isinstance(lltype, ir.LiteralStructType):
+ # Struct type
+ meta = []
+ offset = 0
+ if datamodel is None or not datamodel.inner_models():
+ name = f"Anonymous struct ({str(lltype)})"
+ for field_id, element in enumerate(lltype.elements):
+ size = self.cgctx.get_abi_sizeof(element)
+ basetype = self._var_type(element, size)
+ derived_type = m.add_debug_info('DIDerivedType', {
+ 'tag': ir.DIToken('DW_TAG_member'),
+ 'name': f'',
+ 'baseType': basetype,
+ 'size': _BYTE_SIZE * size, # DW_TAG_member size is in bits
+ 'offset': offset,
+ })
+ meta.append(derived_type)
+ offset += (_BYTE_SIZE * size) # offset is in bits
+ else:
+ name = f"{datamodel.fe_type} ({str(lltype)})"
+ for element, field, model in zip(lltype.elements,
+ datamodel._fields,
+ datamodel.inner_models()):
+ size = self.cgctx.get_abi_sizeof(element)
+ basetype = self._var_type(element, size, datamodel=model)
+ derived_type = m.add_debug_info('DIDerivedType', {
+ 'tag': ir.DIToken('DW_TAG_member'),
+ 'name': field,
+ 'baseType': basetype,
+ 'size': _BYTE_SIZE * size, # DW_TAG_member size is in bits
+ 'offset': offset,
+ })
+ meta.append(derived_type)
+ offset += (_BYTE_SIZE * size) # offset is in bits
+
+ mdtype = m.add_debug_info('DICompositeType', {
+ 'tag': ir.DIToken('DW_TAG_structure_type'),
+ 'name': name,
+ 'identifier': str(lltype),
+ 'elements': m.add_metadata(meta),
+ 'size': offset,
+ }, is_distinct=True)
+ elif isinstance(lltype, ir.ArrayType):
+ element = lltype.element
+ el_size = self.cgctx.get_abi_sizeof(element)
+ basetype = self._var_type(element, el_size)
+ count = size // el_size
+ mdrange = m.add_debug_info('DISubrange', {
+ 'count': count,
+ })
+ mdtype = m.add_debug_info('DICompositeType', {
+ 'tag': ir.DIToken('DW_TAG_array_type'),
+ 'baseType': basetype,
+ 'name': str(lltype),
+ 'size': bitsize,
+ 'identifier': str(lltype),
+ 'elements': m.add_metadata([mdrange]),
+ })
+ else:
+ # For all other types, describe it as sequence of bytes
+ count = size
+ mdrange = m.add_debug_info('DISubrange', {
+ 'count': count,
+ })
+ mdbase = m.add_debug_info('DIBasicType', {
+ 'name': 'byte',
+ 'size': _BYTE_SIZE,
+ 'encoding': ir.DIToken('DW_ATE_unsigned_char'),
+ })
+ mdtype = m.add_debug_info('DICompositeType', {
+ 'tag': ir.DIToken('DW_TAG_array_type'),
+ 'baseType': mdbase,
+ 'name': str(lltype),
+ 'size': bitsize,
+ 'identifier': str(lltype),
+ 'elements': m.add_metadata([mdrange]),
+ })
+
+ return mdtype
+
+ def mark_variable(self, builder, allocavalue, name, lltype, size, line,
+ datamodel=None, argidx=None):
+
+ arg_index = 0 if argidx is None else argidx
+ m = self.module
+ fnty = ir.FunctionType(ir.VoidType(), [ir.MetaDataType()] * 3)
+ decl = cgutils.get_or_insert_function(m, fnty, 'llvm.dbg.declare')
+
+ mdtype = self._var_type(lltype, size, datamodel=datamodel)
+ name = name.replace('.', '$') # for gdb to work correctly
+ mdlocalvar = m.add_debug_info('DILocalVariable', {
+ 'name': name,
+ 'arg': arg_index,
+ 'scope': self.subprograms[-1],
+ 'file': self.difile,
+ 'line': line,
+ 'type': mdtype,
+ })
+ mdexpr = m.add_debug_info('DIExpression', {})
+
+ return builder.call(decl, [allocavalue, mdlocalvar, mdexpr])
+
+ def mark_location(self, builder, line):
+ builder.debug_metadata = self._add_location(line)
+
+ def mark_subprogram(self, function, qualname, argnames, argtypes, line):
+ name = qualname
+ argmap = dict(zip(argnames, argtypes))
+ di_subp = self._add_subprogram(name=name, linkagename=function.name,
+ line=line, function=function,
+ argmap=argmap)
+ function.set_metadata("dbg", di_subp)
+
+ def finalize(self):
+ dbgcu = cgutils.get_or_insert_named_metadata(self.module, self.DBG_CU_NAME)
+ dbgcu.add(self.dicompileunit)
+ self._set_module_flags()
+
+ #
+ # Internal APIs
+ #
+
+ def _set_module_flags(self):
+ """Set the module flags metadata
+ """
+ module = self.module
+ mflags = cgutils.get_or_insert_named_metadata(module, 'llvm.module.flags')
+ # Set *require* behavior to warning
+ # See http://llvm.org/docs/LangRef.html#module-flags-metadata
+ require_warning_behavior = self._const_int(2)
+ if self.DWARF_VERSION is not None:
+ dwarf_version = module.add_metadata([
+ require_warning_behavior,
+ "Dwarf Version",
+ self._const_int(self.DWARF_VERSION)
+ ])
+ if dwarf_version not in mflags.operands:
+ mflags.add(dwarf_version)
+ debuginfo_version = module.add_metadata([
+ require_warning_behavior,
+ "Debug Info Version",
+ self._const_int(self.DEBUG_INFO_VERSION)
+ ])
+ if debuginfo_version not in mflags.operands:
+ mflags.add(debuginfo_version)
+
+ def _add_subprogram(self, name, linkagename, line, function, argmap):
+ """Emit subprogram metadata
+ """
+ subp = self._di_subprogram(name, linkagename, line, function, argmap)
+ self.subprograms.append(subp)
+ return subp
+
+ def _add_location(self, line):
+ """Emit location metatdaa
+ """
+ loc = self._di_location(line)
+ return loc
+
+ @classmethod
+ def _const_int(cls, num, bits=32):
+ """Util to create constant int in metadata
+ """
+ return ir.IntType(bits)(num)
+
+ @classmethod
+ def _const_bool(cls, boolean):
+ """Util to create constant boolean in metadata
+ """
+ return ir.IntType(1)(boolean)
+
+ #
+ # Helpers to emit the metadata nodes
+ #
+
+ def _di_file(self):
+ return self.module.add_debug_info('DIFile', {
+ 'directory': os.path.dirname(self.filepath),
+ 'filename': os.path.basename(self.filepath),
+ })
+
+ def _di_compile_unit(self):
+ return self.module.add_debug_info('DICompileUnit', {
+ 'language': ir.DIToken('DW_LANG_C_plus_plus'),
+ 'file': self.difile,
+ # Numba has to pretend to be clang to ensure the prologue is skipped
+ # correctly in gdb. See:
+ # https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/amd64-tdep.c;h=e563d369d8cb3eb3c2f732c2fa850ec70ba8d63b;hb=a4b0231e179607e47b1cdf1fe15c5dc25e482fad#l2521
+ # Note the "producer_is_llvm" call to specialise the prologue
+ # handling, this is defined here:
+ # https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/producer.c;h=cdfd80d904c09394febd18749bb90359b2d128cc;hb=a4b0231e179607e47b1cdf1fe15c5dc25e482fad#l124
+ # and to get a match for this condition the 'producer' must start
+ # with "clang ", hence the following...
+ 'producer': 'clang (Numba)',
+ 'runtimeVersion': 0,
+ 'isOptimized': config.OPT != 0,
+ 'emissionKind': ir.DIToken(self.emission_kind),
+ }, is_distinct=True)
+
+ def _di_subroutine_type(self, line, function, argmap):
+ # The function call conv needs encoding.
+ llfunc = function
+ md = []
+
+ for idx, llarg in enumerate(llfunc.args):
+ if not llarg.name.startswith('arg.'):
+ name = llarg.name.replace('.', '$') # for gdb to work correctly
+ lltype = llarg.type
+ size = self.cgctx.get_abi_sizeof(lltype)
+ mdtype = self._var_type(lltype, size, datamodel=None)
+ md.append(mdtype)
+
+ for idx, (name, nbtype) in enumerate(argmap.items()):
+ name = name.replace('.', '$') # for gdb to work correctly
+ datamodel = self.cgctx.data_model_manager[nbtype]
+ lltype = self.cgctx.get_value_type(nbtype)
+ size = self.cgctx.get_abi_sizeof(lltype)
+ mdtype = self._var_type(lltype, size, datamodel=datamodel)
+ md.append(mdtype)
+
+ return self.module.add_debug_info('DISubroutineType', {
+ 'types': self.module.add_metadata(md),
+ })
+
+ def _di_subprogram(self, name, linkagename, line, function, argmap):
+ return self.module.add_debug_info('DISubprogram', {
+ 'name': name,
+ 'linkageName': linkagename,
+ 'scope': self.difile,
+ 'file': self.difile,
+ 'line': line,
+ 'type': self._di_subroutine_type(line, function, argmap),
+ 'isLocal': False,
+ 'isDefinition': True,
+ 'scopeLine': line,
+ 'isOptimized': config.OPT != 0,
+ 'unit': self.dicompileunit,
+ }, is_distinct=True)
+
+ def _di_location(self, line):
+ return self.module.add_debug_info('DILocation', {
+ 'line': line,
+ 'column': 1,
+ 'scope': self.subprograms[-1],
+ })
diff --git a/venv/lib/python3.10/site-packages/numba/core/decorators.py b/venv/lib/python3.10/site-packages/numba/core/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..6801a8e04cdcc2d3e84fbe21b2d450bb5a7638b4
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/decorators.py
@@ -0,0 +1,302 @@
+"""
+Define @jit and related decorators.
+"""
+
+
+import sys
+import warnings
+import inspect
+import logging
+
+from numba.core.errors import DeprecationError, NumbaDeprecationWarning
+from numba.stencils.stencil import stencil
+from numba.core import config, extending, sigutils, registry
+
+_logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Decorators
+
+_msg_deprecated_signature_arg = ("Deprecated keyword argument `{0}`. "
+ "Signatures should be passed as the first "
+ "positional argument.")
+
+
+def jit(signature_or_function=None, locals={}, cache=False,
+ pipeline_class=None, boundscheck=None, **options):
+ """
+ This decorator is used to compile a Python function into native code.
+
+ Args
+ -----
+ signature_or_function:
+ The (optional) signature or list of signatures to be compiled.
+ If not passed, required signatures will be compiled when the
+ decorated function is called, depending on the argument values.
+ As a convenience, you can directly pass the function to be compiled
+ instead.
+
+ locals: dict
+ Mapping of local variable names to Numba types. Used to override the
+ types deduced by Numba's type inference engine.
+
+ pipeline_class: type numba.compiler.CompilerBase
+ The compiler pipeline type for customizing the compilation stages.
+
+ options:
+ For a cpu target, valid options are:
+ nopython: bool
+ Set to True to disable the use of PyObjects and Python API
+ calls. The default behavior is to allow the use of PyObjects
+ and Python API. Default value is True.
+
+ forceobj: bool
+ Set to True to force the use of PyObjects for every value.
+ Default value is False.
+
+ looplift: bool
+ Set to True to enable jitting loops in nopython mode while
+ leaving surrounding code in object mode. This allows functions
+ to allocate NumPy arrays and use Python objects, while the
+ tight loops in the function can still be compiled in nopython
+ mode. Any arrays that the tight loop uses should be created
+ before the loop is entered. Default value is True.
+
+ error_model: str
+ The error-model affects divide-by-zero behavior.
+ Valid values are 'python' and 'numpy'. The 'python' model
+ raises exception. The 'numpy' model sets the result to
+ *+/-inf* or *nan*. Default value is 'python'.
+
+ inline: str or callable
+ The inline option will determine whether a function is inlined
+ at into its caller if called. String options are 'never'
+ (default) which will never inline, and 'always', which will
+ always inline. If a callable is provided it will be called with
+ the call expression node that is requesting inlining, the
+ caller's IR and callee's IR as arguments, it is expected to
+ return Truthy as to whether to inline.
+ NOTE: This inlining is performed at the Numba IR level and is in
+ no way related to LLVM inlining.
+
+ boundscheck: bool or None
+ Set to True to enable bounds checking for array indices. Out
+ of bounds accesses will raise IndexError. The default is to
+ not do bounds checking. If False, bounds checking is disabled,
+ out of bounds accesses can produce garbage results or segfaults.
+ However, enabling bounds checking will slow down typical
+ functions, so it is recommended to only use this flag for
+ debugging. You can also set the NUMBA_BOUNDSCHECK environment
+ variable to 0 or 1 to globally override this flag. The default
+ value is None, which under normal execution equates to False,
+ but if debug is set to True then bounds checking will be
+ enabled.
+
+ Returns
+ --------
+ A callable usable as a compiled function. Actual compiling will be
+ done lazily if no explicit signatures are passed.
+
+ Examples
+ --------
+ The function can be used in the following ways:
+
+ 1) jit(signatures, **targetoptions) -> jit(function)
+
+ Equivalent to:
+
+ d = dispatcher(function, targetoptions)
+ for signature in signatures:
+ d.compile(signature)
+
+ Create a dispatcher object for a python function. Then, compile
+ the function with the given signature(s).
+
+ Example:
+
+ @jit("int32(int32, int32)")
+ def foo(x, y):
+ return x + y
+
+ @jit(["int32(int32, int32)", "float32(float32, float32)"])
+ def bar(x, y):
+ return x + y
+
+ 2) jit(function, **targetoptions) -> dispatcher
+
+ Create a dispatcher function object that specializes at call site.
+
+ Examples:
+
+ @jit
+ def foo(x, y):
+ return x + y
+
+ @jit(nopython=True)
+ def bar(x, y):
+ return x + y
+
+ """
+ forceobj = options.get('forceobj', False)
+ if 'argtypes' in options:
+ raise DeprecationError(_msg_deprecated_signature_arg.format('argtypes'))
+ if 'restype' in options:
+ raise DeprecationError(_msg_deprecated_signature_arg.format('restype'))
+ nopython = options.get('nopython', None)
+ if nopython is not None:
+ assert type(nopython) is bool, "nopython option must be a bool"
+ if nopython is True and forceobj:
+ raise ValueError("Only one of 'nopython' or 'forceobj' can be True.")
+ target = options.pop('_target', 'cpu')
+
+ if nopython is False:
+ msg = ("The keyword argument 'nopython=False' was supplied. From "
+ "Numba 0.59.0 the default is True and supplying this argument "
+ "has no effect.")
+ warnings.warn(msg, NumbaDeprecationWarning)
+ # nopython is True by default since 0.59.0, but if `forceobj` is set
+ # `nopython` needs to set to False so that things like typing of args in the
+ # dispatcher layer continues to work.
+ if forceobj:
+ options['nopython'] = False
+ else:
+ options['nopython'] = True
+
+ options['boundscheck'] = boundscheck
+
+ # Handle signature
+ if signature_or_function is None:
+ # No signature, no function
+ pyfunc = None
+ sigs = None
+ elif isinstance(signature_or_function, list):
+ # A list of signatures is passed
+ pyfunc = None
+ sigs = signature_or_function
+ elif sigutils.is_signature(signature_or_function):
+ # A single signature is passed
+ pyfunc = None
+ sigs = [signature_or_function]
+ else:
+ # A function is passed
+ pyfunc = signature_or_function
+ sigs = None
+
+ dispatcher_args = {}
+ if pipeline_class is not None:
+ dispatcher_args['pipeline_class'] = pipeline_class
+ wrapper = _jit(sigs, locals=locals, target=target, cache=cache,
+ targetoptions=options, **dispatcher_args)
+ if pyfunc is not None:
+ return wrapper(pyfunc)
+ else:
+ return wrapper
+
+
+def _jit(sigs, locals, target, cache, targetoptions, **dispatcher_args):
+
+ from numba.core.target_extension import resolve_dispatcher_from_str
+ dispatcher = resolve_dispatcher_from_str(target)
+
+ def wrapper(func):
+ if extending.is_jitted(func):
+ raise TypeError(
+ "A jit decorator was called on an already jitted function "
+ f"{func}. If trying to access the original python "
+ f"function, use the {func}.py_func attribute."
+ )
+
+ if not inspect.isfunction(func):
+ raise TypeError(
+ "The decorated object is not a function (got type "
+ f"{type(func)})."
+ )
+
+ if config.ENABLE_CUDASIM and target == 'cuda':
+ from numba import cuda
+ return cuda.jit(func)
+ if config.DISABLE_JIT and not target == 'npyufunc':
+ return func
+ disp = dispatcher(py_func=func, locals=locals,
+ targetoptions=targetoptions,
+ **dispatcher_args)
+ if cache:
+ disp.enable_caching()
+ if sigs is not None:
+ # Register the Dispatcher to the type inference mechanism,
+ # even though the decorator hasn't returned yet.
+ from numba.core import typeinfer
+ with typeinfer.register_dispatcher(disp):
+ for sig in sigs:
+ disp.compile(sig)
+ disp.disable_compile()
+ return disp
+
+ return wrapper
+
+
+def njit(*args, **kws):
+ """
+ Equivalent to jit(nopython=True)
+
+ See documentation for jit function/decorator for full description.
+ """
+ if 'nopython' in kws:
+ warnings.warn('nopython is set for njit and is ignored', RuntimeWarning)
+ if 'forceobj' in kws:
+ warnings.warn('forceobj is set for njit and is ignored', RuntimeWarning)
+ del kws['forceobj']
+ kws.update({'nopython': True})
+ return jit(*args, **kws)
+
+
+def cfunc(sig, locals={}, cache=False, pipeline_class=None, **options):
+ """
+ This decorator is used to compile a Python function into a C callback
+ usable with foreign C libraries.
+
+ Usage::
+ @cfunc("float64(float64, float64)", nopython=True, cache=True)
+ def add(a, b):
+ return a + b
+
+ """
+ sig = sigutils.normalize_signature(sig)
+
+ def wrapper(func):
+ from numba.core.ccallback import CFunc
+ additional_args = {}
+ if pipeline_class is not None:
+ additional_args['pipeline_class'] = pipeline_class
+ res = CFunc(func, sig, locals=locals, options=options, **additional_args)
+ if cache:
+ res.enable_caching()
+ res.compile()
+ return res
+
+ return wrapper
+
+
+def jit_module(**kwargs):
+ """ Automatically ``jit``-wraps functions defined in a Python module
+
+ Note that ``jit_module`` should only be called at the end of the module to
+ be jitted. In addition, only functions which are defined in the module
+ ``jit_module`` is called from are considered for automatic jit-wrapping.
+ See the Numba documentation for more information about what can/cannot be
+ jitted.
+
+ :param kwargs: Keyword arguments to pass to ``jit`` such as ``nopython``
+ or ``error_model``.
+
+ """
+ # Get the module jit_module is being called from
+ frame = inspect.stack()[1]
+ module = inspect.getmodule(frame[0])
+ # Replace functions in module with jit-wrapped versions
+ for name, obj in module.__dict__.items():
+ if inspect.isfunction(obj) and inspect.getmodule(obj) == module:
+ _logger.debug("Auto decorating function {} from module {} with jit "
+ "and options: {}".format(obj, module.__name__, kwargs))
+ module.__dict__[name] = jit(obj, **kwargs)
diff --git a/venv/lib/python3.10/site-packages/numba/core/descriptors.py b/venv/lib/python3.10/site-packages/numba/core/descriptors.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c0c367e9c99dc2799cfdb738e62cbd85d93f8eb
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/descriptors.py
@@ -0,0 +1,21 @@
+"""
+Target Descriptors
+"""
+
+from abc import ABCMeta, abstractmethod
+
+
+class TargetDescriptor(metaclass=ABCMeta):
+
+ def __init__(self, target_name):
+ self._target_name = target_name
+
+ @property
+ @abstractmethod
+ def typing_context(self):
+ ...
+
+ @property
+ @abstractmethod
+ def target_context(self):
+ ...
diff --git a/venv/lib/python3.10/site-packages/numba/core/dispatcher.py b/venv/lib/python3.10/site-packages/numba/core/dispatcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c284f024f3b461ddd855f960aa28d474971245f
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/dispatcher.py
@@ -0,0 +1,1333 @@
+# -*- coding: utf-8 -*-
+
+
+import collections
+import functools
+import sys
+import types as pytypes
+import uuid
+import weakref
+from contextlib import ExitStack
+from abc import abstractmethod
+
+from numba import _dispatcher
+from numba.core import (
+ utils, types, errors, typing, serialize, config, compiler, sigutils
+)
+from numba.core.compiler_lock import global_compiler_lock
+from numba.core.typeconv.rules import default_type_manager
+from numba.core.typing.templates import fold_arguments
+from numba.core.typing.typeof import Purpose, typeof
+from numba.core.bytecode import get_code_object
+from numba.core.caching import NullCache, FunctionCache
+from numba.core import entrypoints
+import numba.core.event as ev
+
+
+class OmittedArg(object):
+ """
+ A placeholder for omitted arguments with a default value.
+ """
+
+ def __init__(self, value):
+ self.value = value
+
+ def __repr__(self):
+ return "omitted arg(%r)" % (self.value,)
+
+ @property
+ def _numba_type_(self):
+ return types.Omitted(self.value)
+
+
+class _FunctionCompiler(object):
+ def __init__(self, py_func, targetdescr, targetoptions, locals,
+ pipeline_class):
+ self.py_func = py_func
+ self.targetdescr = targetdescr
+ self.targetoptions = targetoptions
+ self.locals = locals
+ self.pysig = utils.pysignature(self.py_func)
+ self.pipeline_class = pipeline_class
+ # Remember key=(args, return_type) combinations that will fail
+ # compilation to avoid compilation attempt on them. The values are
+ # the exceptions.
+ self._failed_cache = {}
+
+ def fold_argument_types(self, args, kws):
+ """
+ Given positional and named argument types, fold keyword arguments
+ and resolve defaults by inserting types.Omitted() instances.
+
+ A (pysig, argument types) tuple is returned.
+ """
+ def normal_handler(index, param, value):
+ return value
+
+ def default_handler(index, param, default):
+ return types.Omitted(default)
+
+ def stararg_handler(index, param, values):
+ return types.StarArgTuple(values)
+ # For now, we take argument values from the @jit function
+ args = fold_arguments(self.pysig, args, kws,
+ normal_handler,
+ default_handler,
+ stararg_handler)
+ return self.pysig, args
+
+ def compile(self, args, return_type):
+ status, retval = self._compile_cached(args, return_type)
+ if status:
+ return retval
+ else:
+ raise retval
+
+ def _compile_cached(self, args, return_type):
+ key = tuple(args), return_type
+ try:
+ return False, self._failed_cache[key]
+ except KeyError:
+ pass
+
+ try:
+ retval = self._compile_core(args, return_type)
+ except errors.TypingError as e:
+ self._failed_cache[key] = e
+ return False, e
+ else:
+ return True, retval
+
+ def _compile_core(self, args, return_type):
+ flags = compiler.Flags()
+ self.targetdescr.options.parse_as_flags(flags, self.targetoptions)
+ flags = self._customize_flags(flags)
+
+ impl = self._get_implementation(args, {})
+ cres = compiler.compile_extra(self.targetdescr.typing_context,
+ self.targetdescr.target_context,
+ impl,
+ args=args, return_type=return_type,
+ flags=flags, locals=self.locals,
+ pipeline_class=self.pipeline_class)
+ # Check typing error if object mode is used
+ if cres.typing_error is not None and not flags.enable_pyobject:
+ raise cres.typing_error
+ return cres
+
+ def get_globals_for_reduction(self):
+ return serialize._get_function_globals_for_reduction(self.py_func)
+
+ def _get_implementation(self, args, kws):
+ return self.py_func
+
+ def _customize_flags(self, flags):
+ return flags
+
+
+class _GeneratedFunctionCompiler(_FunctionCompiler):
+
+ def __init__(self, py_func, targetdescr, targetoptions, locals,
+ pipeline_class):
+ super(_GeneratedFunctionCompiler, self).__init__(
+ py_func, targetdescr, targetoptions, locals, pipeline_class)
+ self.impls = set()
+
+ def get_globals_for_reduction(self):
+ # This will recursively get the globals used by any nested
+ # implementation function.
+ return serialize._get_function_globals_for_reduction(self.py_func)
+
+ def _get_implementation(self, args, kws):
+ impl = self.py_func(*args, **kws)
+ # Check the generating function and implementation signatures are
+ # compatible, otherwise compiling would fail later.
+ pysig = utils.pysignature(self.py_func)
+ implsig = utils.pysignature(impl)
+ ok = len(pysig.parameters) == len(implsig.parameters)
+ if ok:
+ for pyparam, implparam in zip(pysig.parameters.values(),
+ implsig.parameters.values()):
+ # We allow the implementation to omit default values, but
+ # if it mentions them, they should have the same value...
+ if (pyparam.name != implparam.name or
+ pyparam.kind != implparam.kind or
+ (implparam.default is not implparam.empty and
+ implparam.default != pyparam.default)):
+ ok = False
+ if not ok:
+ raise TypeError("generated implementation %s should be compatible "
+ "with signature '%s', but has signature '%s'"
+ % (impl, pysig, implsig))
+ self.impls.add(impl)
+ return impl
+
+
+_CompileStats = collections.namedtuple(
+ '_CompileStats', ('cache_path', 'cache_hits', 'cache_misses'))
+
+
+class CompilingCounter(object):
+ """
+ A simple counter that increment in __enter__ and decrement in __exit__.
+ """
+
+ def __init__(self):
+ self.counter = 0
+
+ def __enter__(self):
+ assert self.counter >= 0
+ self.counter += 1
+
+ def __exit__(self, *args, **kwargs):
+ self.counter -= 1
+ assert self.counter >= 0
+
+ def __bool__(self):
+ return self.counter > 0
+
+ __nonzero__ = __bool__
+
+
+class _DispatcherBase(_dispatcher.Dispatcher):
+ """
+ Common base class for dispatcher Implementations.
+ """
+
+ __numba__ = "py_func"
+
+ def __init__(self, arg_count, py_func, pysig, can_fallback,
+ exact_match_required):
+ self._tm = default_type_manager
+
+ # A mapping of signatures to compile results
+ self.overloads = collections.OrderedDict()
+
+ self.py_func = py_func
+ # other parts of Numba assume the old Python 2 name for code object
+ self.func_code = get_code_object(py_func)
+ # but newer python uses a different name
+ self.__code__ = self.func_code
+ # a place to keep an active reference to the types of the active call
+ self._types_active_call = set()
+ # Default argument values match the py_func
+ self.__defaults__ = py_func.__defaults__
+
+ argnames = tuple(pysig.parameters)
+ default_values = self.py_func.__defaults__ or ()
+ defargs = tuple(OmittedArg(val) for val in default_values)
+ try:
+ lastarg = list(pysig.parameters.values())[-1]
+ except IndexError:
+ has_stararg = False
+ else:
+ has_stararg = lastarg.kind == lastarg.VAR_POSITIONAL
+ _dispatcher.Dispatcher.__init__(self, self._tm.get_pointer(),
+ arg_count, self._fold_args,
+ argnames, defargs,
+ can_fallback,
+ has_stararg,
+ exact_match_required)
+
+ self.doc = py_func.__doc__
+ self._compiling_counter = CompilingCounter()
+ self._enable_sysmon = bool(config.ENABLE_SYS_MONITORING)
+ weakref.finalize(self, self._make_finalizer())
+
+ def _compilation_chain_init_hook(self):
+ """
+ This will be called ahead of any part of compilation taking place (this
+ even includes being ahead of working out the types of the arguments).
+ This permits activities such as initialising extension entry points so
+ that the compiler knows about additional externally defined types etc
+ before it does anything.
+ """
+ entrypoints.init_all()
+
+ def _reset_overloads(self):
+ self._clear()
+ self.overloads.clear()
+
+ def _make_finalizer(self):
+ """
+ Return a finalizer function that will release references to
+ related compiled functions.
+ """
+ overloads = self.overloads
+ targetctx = self.targetctx
+
+ # Early-bind utils.shutting_down() into the function's local namespace
+ # (see issue #689)
+ def finalizer(shutting_down=utils.shutting_down):
+ # The finalizer may crash at shutdown, skip it (resources
+ # will be cleared by the process exiting, anyway).
+ if shutting_down():
+ return
+ # This function must *not* hold any reference to self:
+ # we take care to bind the necessary objects in the closure.
+ for cres in overloads.values():
+ try:
+ targetctx.remove_user_function(cres.entry_point)
+ except KeyError:
+ pass
+
+ return finalizer
+
+ @property
+ def signatures(self):
+ """
+ Returns a list of compiled function signatures.
+ """
+ return list(self.overloads)
+
+ @property
+ def nopython_signatures(self):
+ return [cres.signature for cres in self.overloads.values()
+ if not cres.objectmode]
+
+ def disable_compile(self, val=True):
+ """Disable the compilation of new signatures at call time.
+ """
+ # If disabling compilation then there must be at least one signature
+ assert (not val) or len(self.signatures) > 0
+ self._can_compile = not val
+
+ def add_overload(self, cres):
+ args = tuple(cres.signature.args)
+ sig = [a._code for a in args]
+ self._insert(sig, cres.entry_point, cres.objectmode)
+ self.overloads[args] = cres
+
+ def fold_argument_types(self, args, kws):
+ return self._compiler.fold_argument_types(args, kws)
+
+ def get_call_template(self, args, kws):
+ """
+ Get a typing.ConcreteTemplate for this dispatcher and the given
+ *args* and *kws* types. This allows to resolve the return type.
+
+ A (template, pysig, args, kws) tuple is returned.
+ """
+ # XXX how about a dispatcher template class automating the
+ # following?
+
+ # Fold keyword arguments and resolve default values
+ pysig, args = self._compiler.fold_argument_types(args, kws)
+ kws = {}
+ # Ensure an overload is available
+ if self._can_compile:
+ self.compile(tuple(args))
+
+ # Create function type for typing
+ func_name = self.py_func.__name__
+ name = "CallTemplate({0})".format(func_name)
+ # The `key` isn't really used except for diagnosis here,
+ # so avoid keeping a reference to `cfunc`.
+ call_template = typing.make_concrete_template(
+ name, key=func_name, signatures=self.nopython_signatures)
+ return call_template, pysig, args, kws
+
+ def get_overload(self, sig):
+ """
+ Return the compiled function for the given signature.
+ """
+ args, return_type = sigutils.normalize_signature(sig)
+ return self.overloads[tuple(args)].entry_point
+
+ @property
+ def is_compiling(self):
+ """
+ Whether a specialization is currently being compiled.
+ """
+ return self._compiling_counter
+
+ def _compile_for_args(self, *args, **kws):
+ """
+ For internal use. Compile a specialized version of the function
+ for the given *args* and *kws*, and return the resulting callable.
+ """
+ assert not kws
+ # call any initialisation required for the compilation chain (e.g.
+ # extension point registration).
+ self._compilation_chain_init_hook()
+
+ def error_rewrite(e, issue_type):
+ """
+ Rewrite and raise Exception `e` with help supplied based on the
+ specified issue_type.
+ """
+ if config.SHOW_HELP:
+ help_msg = errors.error_extras[issue_type]
+ e.patch_message('\n'.join((str(e).rstrip(), help_msg)))
+ if config.FULL_TRACEBACKS:
+ raise e
+ else:
+ raise e.with_traceback(None)
+
+ argtypes = []
+ for a in args:
+ if isinstance(a, OmittedArg):
+ argtypes.append(types.Omitted(a.value))
+ else:
+ argtypes.append(self.typeof_pyval(a))
+
+ return_val = None
+ try:
+ return_val = self.compile(tuple(argtypes))
+ except errors.ForceLiteralArg as e:
+ # Received request for compiler re-entry with the list of arguments
+ # indicated by e.requested_args.
+ # First, check if any of these args are already Literal-ized
+ already_lit_pos = [i for i in e.requested_args
+ if isinstance(args[i], types.Literal)]
+ if already_lit_pos:
+ # Abort compilation if any argument is already a Literal.
+ # Letting this continue will cause infinite compilation loop.
+ m = ("Repeated literal typing request.\n"
+ "{}.\n"
+ "This is likely caused by an error in typing. "
+ "Please see nested and suppressed exceptions.")
+ info = ', '.join('Arg #{} is {}'.format(i, args[i])
+ for i in sorted(already_lit_pos))
+ raise errors.CompilerError(m.format(info))
+ # Convert requested arguments into a Literal.
+ args = [(types.literal
+ if i in e.requested_args
+ else lambda x: x)(args[i])
+ for i, v in enumerate(args)]
+ # Re-enter compilation with the Literal-ized arguments
+ return_val = self._compile_for_args(*args)
+
+ except errors.TypingError as e:
+ # Intercept typing error that may be due to an argument
+ # that failed inferencing as a Numba type
+ failed_args = []
+ for i, arg in enumerate(args):
+ val = arg.value if isinstance(arg, OmittedArg) else arg
+ try:
+ tp = typeof(val, Purpose.argument)
+ except ValueError as typeof_exc:
+ failed_args.append((i, str(typeof_exc)))
+ else:
+ if tp is None:
+ failed_args.append(
+ (i, f"cannot determine Numba type of value {val}"))
+ if failed_args:
+ # Patch error message to ease debugging
+ args_str = "\n".join(
+ f"- argument {i}: {err}" for i, err in failed_args
+ )
+ msg = (f"{str(e).rstrip()} \n\nThis error may have been caused "
+ f"by the following argument(s):\n{args_str}\n")
+ e.patch_message(msg)
+
+ error_rewrite(e, 'typing')
+ except errors.UnsupportedError as e:
+ # Something unsupported is present in the user code, add help info
+ error_rewrite(e, 'unsupported_error')
+ except (errors.NotDefinedError, errors.RedefinedError,
+ errors.VerificationError) as e:
+ # These errors are probably from an issue with either the code
+ # supplied being syntactically or otherwise invalid
+ error_rewrite(e, 'interpreter')
+ except errors.ConstantInferenceError as e:
+ # this is from trying to infer something as constant when it isn't
+ # or isn't supported as a constant
+ error_rewrite(e, 'constant_inference')
+ except Exception as e:
+ if config.SHOW_HELP:
+ if hasattr(e, 'patch_message'):
+ help_msg = errors.error_extras['reportable']
+ e.patch_message('\n'.join((str(e).rstrip(), help_msg)))
+ # ignore the FULL_TRACEBACKS config, this needs reporting!
+ raise e
+ finally:
+ self._types_active_call.clear()
+ return return_val
+
+ def inspect_llvm(self, signature=None):
+ """Get the LLVM intermediate representation generated by compilation.
+
+ Parameters
+ ----------
+ signature : tuple of numba types, optional
+ Specify a signature for which to obtain the LLVM IR. If None, the
+ IR is returned for all available signatures.
+
+ Returns
+ -------
+ llvm : dict[signature, str] or str
+ Either the LLVM IR string for the specified signature, or, if no
+ signature was given, a dictionary mapping signatures to LLVM IR
+ strings.
+ """
+ if signature is not None:
+ lib = self.overloads[signature].library
+ return lib.get_llvm_str()
+
+ return dict((sig, self.inspect_llvm(sig)) for sig in self.signatures)
+
+ def inspect_asm(self, signature=None):
+ """Get the generated assembly code.
+
+ Parameters
+ ----------
+ signature : tuple of numba types, optional
+ Specify a signature for which to obtain the assembly code. If
+ None, the assembly code is returned for all available signatures.
+
+ Returns
+ -------
+ asm : dict[signature, str] or str
+ Either the assembly code for the specified signature, or, if no
+ signature was given, a dictionary mapping signatures to assembly
+ code.
+ """
+ if signature is not None:
+ lib = self.overloads[signature].library
+ return lib.get_asm_str()
+
+ return dict((sig, self.inspect_asm(sig)) for sig in self.signatures)
+
+ def inspect_types(self, file=None, signature=None,
+ pretty=False, style='default', **kwargs):
+ """Print/return Numba intermediate representation (IR)-annotated code.
+
+ Parameters
+ ----------
+ file : file-like object, optional
+ File to which to print. Defaults to sys.stdout if None. Must be
+ None if ``pretty=True``.
+ signature : tuple of numba types, optional
+ Print/return the intermediate representation for only the given
+ signature. If None, the IR is printed for all available signatures.
+ pretty : bool, optional
+ If True, an Annotate object will be returned that can render the
+ IR with color highlighting in Jupyter and IPython. ``file`` must
+ be None if ``pretty`` is True. Additionally, the ``pygments``
+ library must be installed for ``pretty=True``.
+ style : str, optional
+ Choose a style for rendering. Ignored if ``pretty`` is ``False``.
+ This is directly consumed by ``pygments`` formatters. To see a
+ list of available styles, import ``pygments`` and run
+ ``list(pygments.styles.get_all_styles())``.
+
+ Returns
+ -------
+ annotated : Annotate object, optional
+ Only returned if ``pretty=True``, otherwise this function is only
+ used for its printing side effect. If ``pretty=True``, an Annotate
+ object is returned that can render itself in Jupyter and IPython.
+ """
+ overloads = self.overloads
+ if signature is not None:
+ overloads = {signature: self.overloads[signature]}
+
+ if not pretty:
+ if file is None:
+ file = sys.stdout
+
+ for ver, res in overloads.items():
+ print("%s %s" % (self.py_func.__name__, ver), file=file)
+ print('-' * 80, file=file)
+ print(res.type_annotation, file=file)
+ print('=' * 80, file=file)
+ else:
+ if file is not None:
+ raise ValueError("`file` must be None if `pretty=True`")
+ from numba.core.annotations.pretty_annotate import Annotate
+ return Annotate(self, signature=signature, style=style)
+
+ def inspect_cfg(self, signature=None, show_wrapper=None, **kwargs):
+ """
+ For inspecting the CFG of the function.
+
+ By default the CFG of the user function is shown. The *show_wrapper*
+ option can be set to "python" or "cfunc" to show the python wrapper
+ function or the *cfunc* wrapper function, respectively.
+
+ Parameters accepted in kwargs
+ -----------------------------
+ filename : string, optional
+ the name of the output file, if given this will write the output to
+ filename
+ view : bool, optional
+ whether to immediately view the optional output file
+ highlight : bool, set, dict, optional
+ what, if anything, to highlight, options are:
+ { incref : bool, # highlight NRT_incref calls
+ decref : bool, # highlight NRT_decref calls
+ returns : bool, # highlight exits which are normal returns
+ raises : bool, # highlight exits which are from raise
+ meminfo : bool, # highlight calls to NRT*meminfo
+ branches : bool, # highlight true/false branches
+ }
+ Default is True which sets all of the above to True. Supplying a set
+ of strings is also accepted, these are interpreted as key:True with
+ respect to the above dictionary. e.g. {'incref', 'decref'} would
+ switch on highlighting on increfs and decrefs.
+ interleave: bool, set, dict, optional
+ what, if anything, to interleave in the LLVM IR, options are:
+ { python: bool # interleave python source code with the LLVM IR
+ lineinfo: bool # interleave line information markers with the LLVM
+ # IR
+ }
+ Default is True which sets all of the above to True. Supplying a set
+ of strings is also accepted, these are interpreted as key:True with
+ respect to the above dictionary. e.g. {'python',} would
+ switch on interleaving of python source code in the LLVM IR.
+ strip_ir : bool, optional
+ Default is False. If set to True all LLVM IR that is superfluous to
+ that requested in kwarg `highlight` will be removed.
+ show_key : bool, optional
+ Default is True. Create a "key" for the highlighting in the rendered
+ CFG.
+ fontsize : int, optional
+ Default is 8. Set the fontsize in the output to this value.
+ """
+ if signature is not None:
+ cres = self.overloads[signature]
+ lib = cres.library
+ if show_wrapper == 'python':
+ fname = cres.fndesc.llvm_cpython_wrapper_name
+ elif show_wrapper == 'cfunc':
+ fname = cres.fndesc.llvm_cfunc_wrapper_name
+ else:
+ fname = cres.fndesc.mangled_name
+ return lib.get_function_cfg(fname, py_func=self.py_func, **kwargs)
+
+ return dict((sig, self.inspect_cfg(sig, show_wrapper=show_wrapper))
+ for sig in self.signatures)
+
+ def inspect_disasm_cfg(self, signature=None):
+ """
+ For inspecting the CFG of the disassembly of the function.
+
+ Requires python package: r2pipe
+ Requires radare2 binary on $PATH.
+ Notebook rendering requires python package: graphviz
+
+ signature : tuple of Numba types, optional
+ Print/return the disassembly CFG for only the given signatures.
+ If None, the IR is printed for all available signatures.
+ """
+ if signature is not None:
+ cres = self.overloads[signature]
+ lib = cres.library
+ return lib.get_disasm_cfg(cres.fndesc.mangled_name)
+
+ return dict((sig, self.inspect_disasm_cfg(sig))
+ for sig in self.signatures)
+
+ def get_annotation_info(self, signature=None):
+ """
+ Gets the annotation information for the function specified by
+ signature. If no signature is supplied a dictionary of signature to
+ annotation information is returned.
+ """
+ signatures = self.signatures if signature is None else [signature]
+ out = collections.OrderedDict()
+ for sig in signatures:
+ cres = self.overloads[sig]
+ ta = cres.type_annotation
+ key = (ta.func_id.filename + ':' + str(ta.func_id.firstlineno + 1),
+ ta.signature)
+ out[key] = ta.annotate_raw()[key]
+ return out
+
+ def _explain_ambiguous(self, *args, **kws):
+ """
+ Callback for the C _Dispatcher object.
+ """
+ assert not kws, "kwargs not handled"
+ args = tuple([self.typeof_pyval(a) for a in args])
+ # The order here must be deterministic for testing purposes, which
+ # is ensured by the OrderedDict.
+ sigs = self.nopython_signatures
+ # This will raise
+ self.typingctx.resolve_overload(self.py_func, sigs, args, kws,
+ allow_ambiguous=False)
+
+ def _explain_matching_error(self, *args, **kws):
+ """
+ Callback for the C _Dispatcher object.
+ """
+ assert not kws, "kwargs not handled"
+ args = [self.typeof_pyval(a) for a in args]
+ msg = ("No matching definition for argument type(s) %s"
+ % ', '.join(map(str, args)))
+ raise TypeError(msg)
+
+ def _search_new_conversions(self, *args, **kws):
+ """
+ Callback for the C _Dispatcher object.
+ Search for approximately matching signatures for the given arguments,
+ and ensure the corresponding conversions are registered in the C++
+ type manager.
+ """
+ assert not kws, "kwargs not handled"
+ args = [self.typeof_pyval(a) for a in args]
+ found = False
+ for sig in self.nopython_signatures:
+ conv = self.typingctx.install_possible_conversions(args, sig.args)
+ if conv:
+ found = True
+ return found
+
+ def __repr__(self):
+ return "%s(%s)" % (type(self).__name__, self.py_func)
+
+ def typeof_pyval(self, val):
+ """
+ Resolve the Numba type of Python value *val*.
+ This is called from numba._dispatcher as a fallback if the native code
+ cannot decide the type.
+ """
+ try:
+ tp = typeof(val, Purpose.argument)
+ except ValueError:
+ tp = types.pyobject
+ else:
+ if tp is None:
+ tp = types.pyobject
+ self._types_active_call.add(tp)
+ return tp
+
+ def _callback_add_timer(self, duration, cres, lock_name):
+ md = cres.metadata
+ # md can be None when code is loaded from cache
+ if md is not None:
+ timers = md.setdefault("timers", {})
+ if lock_name not in timers:
+ # Only write if the metadata does not exist
+ timers[lock_name] = duration
+ else:
+ msg = f"'{lock_name} metadata is already defined."
+ raise AssertionError(msg)
+
+ def _callback_add_compiler_timer(self, duration, cres):
+ return self._callback_add_timer(duration, cres,
+ lock_name="compiler_lock")
+
+ def _callback_add_llvm_timer(self, duration, cres):
+ return self._callback_add_timer(duration, cres,
+ lock_name="llvm_lock")
+
+
+class _MemoMixin:
+ __uuid = None
+ # A {uuid -> instance} mapping, for deserialization
+ _memo = weakref.WeakValueDictionary()
+ # hold refs to last N functions deserialized, retaining them in _memo
+ # regardless of whether there is another reference
+ _recent = collections.deque(maxlen=config.FUNCTION_CACHE_SIZE)
+
+ @property
+ def _uuid(self):
+ """
+ An instance-specific UUID, to avoid multiple deserializations of
+ a given instance.
+
+ Note: this is lazily-generated, for performance reasons.
+ """
+ u = self.__uuid
+ if u is None:
+ u = str(uuid.uuid4())
+ self._set_uuid(u)
+ return u
+
+ def _set_uuid(self, u):
+ assert self.__uuid is None
+ self.__uuid = u
+ self._memo[u] = self
+ self._recent.append(self)
+
+
+class Dispatcher(serialize.ReduceMixin, _MemoMixin, _DispatcherBase):
+ """
+ Implementation of user-facing dispatcher objects (i.e. created using
+ the @jit decorator).
+ This is an abstract base class. Subclasses should define the targetdescr
+ class attribute.
+ """
+ _fold_args = True
+
+ __numba__ = 'py_func'
+
+ def __init__(self, py_func, locals={}, targetoptions={},
+ pipeline_class=compiler.Compiler):
+ """
+ Parameters
+ ----------
+ py_func: function object to be compiled
+ locals: dict, optional
+ Mapping of local variable names to Numba types. Used to override
+ the types deduced by the type inference engine.
+ targetoptions: dict, optional
+ Target-specific config options.
+ pipeline_class: type numba.compiler.CompilerBase
+ The compiler pipeline type.
+ """
+ self.typingctx = self.targetdescr.typing_context
+ self.targetctx = self.targetdescr.target_context
+
+ pysig = utils.pysignature(py_func)
+ arg_count = len(pysig.parameters)
+ can_fallback = not targetoptions.get('nopython', False)
+
+ _DispatcherBase.__init__(self, arg_count, py_func, pysig, can_fallback,
+ exact_match_required=False)
+
+ functools.update_wrapper(self, py_func)
+
+ self.targetoptions = targetoptions
+ self.locals = locals
+ self._cache = NullCache()
+ compiler_class = _FunctionCompiler
+ self._compiler = compiler_class(py_func, self.targetdescr,
+ targetoptions, locals, pipeline_class)
+ self._cache_hits = collections.Counter()
+ self._cache_misses = collections.Counter()
+
+ self._type = types.Dispatcher(self)
+ self.typingctx.insert_global(self, self._type)
+
+ def dump(self, tab=''):
+ print(f'{tab}DUMP {type(self).__name__}[{self.py_func.__name__}'
+ f', type code={self._type._code}]')
+ for cres in self.overloads.values():
+ cres.dump(tab=tab + ' ')
+ print(f'{tab}END DUMP {type(self).__name__}[{self.py_func.__name__}]')
+
+ @property
+ def _numba_type_(self):
+ return types.Dispatcher(self)
+
+ def enable_caching(self):
+ self._cache = FunctionCache(self.py_func)
+
+ def __get__(self, obj, objtype=None):
+ '''Allow a JIT function to be bound as a method to an object'''
+ if obj is None: # Unbound method
+ return self
+ else: # Bound method
+ return pytypes.MethodType(self, obj)
+
+ def _reduce_states(self):
+ """
+ Reduce the instance for pickling. This will serialize
+ the original function as well the compilation options and
+ compiled signatures, but not the compiled code itself.
+
+ NOTE: part of ReduceMixin protocol
+ """
+ if self._can_compile:
+ sigs = []
+ else:
+ sigs = [cr.signature for cr in self.overloads.values()]
+
+ return dict(
+ uuid=str(self._uuid),
+ py_func=self.py_func,
+ locals=self.locals,
+ targetoptions=self.targetoptions,
+ can_compile=self._can_compile,
+ sigs=sigs,
+ )
+
+ @classmethod
+ def _rebuild(cls, uuid, py_func, locals, targetoptions,
+ can_compile, sigs):
+ """
+ Rebuild an Dispatcher instance after it was __reduce__'d.
+
+ NOTE: part of ReduceMixin protocol
+ """
+ try:
+ return cls._memo[uuid]
+ except KeyError:
+ pass
+ self = cls(py_func, locals, targetoptions)
+ # Make sure this deserialization will be merged with subsequent ones
+ self._set_uuid(uuid)
+ for sig in sigs:
+ self.compile(sig)
+ self._can_compile = can_compile
+ return self
+
+ def compile(self, sig):
+ with ExitStack() as scope:
+ cres = None
+
+ def cb_compiler(dur):
+ if cres is not None:
+ self._callback_add_compiler_timer(dur, cres)
+
+ def cb_llvm(dur):
+ if cres is not None:
+ self._callback_add_llvm_timer(dur, cres)
+
+ scope.enter_context(ev.install_timer("numba:compiler_lock",
+ cb_compiler))
+ scope.enter_context(ev.install_timer("numba:llvm_lock", cb_llvm))
+ scope.enter_context(global_compiler_lock)
+
+ if not self._can_compile:
+ raise RuntimeError("compilation disabled")
+ # Use counter to track recursion compilation depth
+ with self._compiling_counter:
+ args, return_type = sigutils.normalize_signature(sig)
+ # Don't recompile if signature already exists
+ existing = self.overloads.get(tuple(args))
+ if existing is not None:
+ return existing.entry_point
+ # Try to load from disk cache
+ cres = self._cache.load_overload(sig, self.targetctx)
+ if cres is not None:
+ self._cache_hits[sig] += 1
+ # XXX fold this in add_overload()? (also see compiler.py)
+ if not cres.objectmode:
+ self.targetctx.insert_user_function(cres.entry_point,
+ cres.fndesc,
+ [cres.library])
+ self.add_overload(cres)
+ return cres.entry_point
+
+ self._cache_misses[sig] += 1
+ ev_details = dict(
+ dispatcher=self,
+ args=args,
+ return_type=return_type,
+ )
+ with ev.trigger_event("numba:compile", data=ev_details):
+ try:
+ cres = self._compiler.compile(args, return_type)
+ except errors.ForceLiteralArg as e:
+ def folded(args, kws):
+ return self._compiler.fold_argument_types(args,
+ kws)[1]
+ raise e.bind_fold_arguments(folded)
+ self.add_overload(cres)
+ self._cache.save_overload(sig, cres)
+ return cres.entry_point
+
+ def get_compile_result(self, sig):
+ """Compile (if needed) and return the compilation result with the
+ given signature.
+
+ Returns ``CompileResult``.
+ Raises ``NumbaError`` if the signature is incompatible.
+ """
+ atypes = tuple(sig.args)
+ if atypes not in self.overloads:
+ if self._can_compile:
+ # Compiling may raise any NumbaError
+ self.compile(atypes)
+ else:
+ msg = f"{sig} not available and compilation disabled"
+ raise errors.TypingError(msg)
+ return self.overloads[atypes]
+
+ def recompile(self):
+ """
+ Recompile all signatures afresh.
+ """
+ sigs = list(self.overloads)
+ old_can_compile = self._can_compile
+ # Ensure the old overloads are disposed of,
+ # including compiled functions.
+ self._make_finalizer()()
+ self._reset_overloads()
+ self._cache.flush()
+ self._can_compile = True
+ try:
+ for sig in sigs:
+ self.compile(sig)
+ finally:
+ self._can_compile = old_can_compile
+
+ @property
+ def stats(self):
+ return _CompileStats(
+ cache_path=self._cache.cache_path,
+ cache_hits=self._cache_hits,
+ cache_misses=self._cache_misses,
+ )
+
+ def parallel_diagnostics(self, signature=None, level=1):
+ """
+ Print parallel diagnostic information for the given signature. If no
+ signature is present it is printed for all known signatures. level is
+ used to adjust the verbosity, level=1 (default) is minimal verbosity,
+ and 2, 3, and 4 provide increasing levels of verbosity.
+ """
+ def dump(sig):
+ ol = self.overloads[sig]
+ pfdiag = ol.metadata.get('parfor_diagnostics', None)
+ if pfdiag is None:
+ msg = "No parfors diagnostic available, is 'parallel=True' set?"
+ raise ValueError(msg)
+ pfdiag.dump(level)
+ if signature is not None:
+ dump(signature)
+ else:
+ [dump(sig) for sig in self.signatures]
+
+ def get_metadata(self, signature=None):
+ """
+ Obtain the compilation metadata for a given signature.
+ """
+ if signature is not None:
+ return self.overloads[signature].metadata
+ else:
+ return dict(
+ (sig,self.overloads[sig].metadata) for sig in self.signatures
+ )
+
+ def get_function_type(self):
+ """Return unique function type of dispatcher when possible, otherwise
+ return None.
+
+ A Dispatcher instance has unique function type when it
+ contains exactly one compilation result and its compilation
+ has been disabled (via its disable_compile method).
+ """
+ if not self._can_compile and len(self.overloads) == 1:
+ cres = tuple(self.overloads.values())[0]
+ return types.FunctionType(cres.signature)
+
+
+class LiftedCode(serialize.ReduceMixin, _MemoMixin, _DispatcherBase):
+ """
+ Implementation of the hidden dispatcher objects used for lifted code
+ (a lifted loop is really compiled as a separate function).
+ """
+ _fold_args = False
+ can_cache = False
+
+ def __init__(self, func_ir, typingctx, targetctx, flags, locals):
+ self.func_ir = func_ir
+ self.lifted_from = None
+
+ self.typingctx = typingctx
+ self.targetctx = targetctx
+ self.flags = flags
+ self.locals = locals
+
+ _DispatcherBase.__init__(self, self.func_ir.arg_count,
+ self.func_ir.func_id.func,
+ self.func_ir.func_id.pysig,
+ can_fallback=True,
+ exact_match_required=False)
+
+ def _reduce_states(self):
+ """
+ Reduce the instance for pickling. This will serialize
+ the original function as well the compilation options and
+ compiled signatures, but not the compiled code itself.
+
+ NOTE: part of ReduceMixin protocol
+ """
+ return dict(
+ uuid=self._uuid, func_ir=self.func_ir, flags=self.flags,
+ locals=self.locals, extras=self._reduce_extras(),
+ )
+
+ def _reduce_extras(self):
+ """
+ NOTE: sub-class can override to add extra states
+ """
+ return {}
+
+ @classmethod
+ def _rebuild(cls, uuid, func_ir, flags, locals, extras):
+ """
+ Rebuild an Dispatcher instance after it was __reduce__'d.
+
+ NOTE: part of ReduceMixin protocol
+ """
+ try:
+ return cls._memo[uuid]
+ except KeyError:
+ pass
+
+ # NOTE: We are assuming that this is must be cpu_target, which is true
+ # for now.
+ # TODO: refactor this to not assume on `cpu_target`
+
+ from numba.core import registry
+ typingctx = registry.cpu_target.typing_context
+ targetctx = registry.cpu_target.target_context
+
+ self = cls(func_ir, typingctx, targetctx, flags, locals, **extras)
+ self._set_uuid(uuid)
+ return self
+
+ def get_source_location(self):
+ """Return the starting line number of the loop.
+ """
+ return self.func_ir.loc.line
+
+ def _pre_compile(self, args, return_type, flags):
+ """Pre-compile actions
+ """
+ pass
+
+ @abstractmethod
+ def compile(self, sig):
+ """Lifted code should implement a compilation method that will return
+ a CompileResult.entry_point for the given signature."""
+ pass
+
+ def _get_dispatcher_for_current_target(self):
+ # Lifted code does not honor the target switch currently.
+ # No work has been done to check if this can be allowed.
+ return self
+
+
+class LiftedLoop(LiftedCode):
+ def _pre_compile(self, args, return_type, flags):
+ assert not flags.enable_looplift, "Enable looplift flags is on"
+
+ def compile(self, sig):
+ with ExitStack() as scope:
+ cres = None
+
+ def cb_compiler(dur):
+ if cres is not None:
+ self._callback_add_compiler_timer(dur, cres)
+
+ def cb_llvm(dur):
+ if cres is not None:
+ self._callback_add_llvm_timer(dur, cres)
+
+ scope.enter_context(ev.install_timer("numba:compiler_lock",
+ cb_compiler))
+ scope.enter_context(ev.install_timer("numba:llvm_lock", cb_llvm))
+ scope.enter_context(global_compiler_lock)
+
+ # Use counter to track recursion compilation depth
+ with self._compiling_counter:
+ # XXX this is mostly duplicated from Dispatcher.
+ flags = self.flags
+ args, return_type = sigutils.normalize_signature(sig)
+
+ # Don't recompile if signature already exists
+ # (e.g. if another thread compiled it before we got the lock)
+ existing = self.overloads.get(tuple(args))
+ if existing is not None:
+ return existing.entry_point
+
+ self._pre_compile(args, return_type, flags)
+
+ # copy the flags, use nopython first
+ npm_loop_flags = flags.copy()
+ npm_loop_flags.force_pyobject = False
+
+ pyobject_loop_flags = flags.copy()
+ pyobject_loop_flags.force_pyobject = True
+
+ # Clone IR to avoid (some of the) mutation in the rewrite pass
+ cloned_func_ir_npm = self.func_ir.copy()
+ cloned_func_ir_fbk = self.func_ir.copy()
+
+ ev_details = dict(
+ dispatcher=self,
+ args=args,
+ return_type=return_type,
+ )
+ with ev.trigger_event("numba:compile", data=ev_details):
+ # this emulates "object mode fall-back", try nopython, if it
+ # fails, then try again in object mode.
+ try:
+ cres = compiler.compile_ir(typingctx=self.typingctx,
+ targetctx=self.targetctx,
+ func_ir=cloned_func_ir_npm,
+ args=args,
+ return_type=return_type,
+ flags=npm_loop_flags,
+ locals=self.locals,
+ lifted=(),
+ lifted_from=self.lifted_from,
+ is_lifted_loop=True,)
+ except errors.TypingError:
+ cres = compiler.compile_ir(typingctx=self.typingctx,
+ targetctx=self.targetctx,
+ func_ir=cloned_func_ir_fbk,
+ args=args,
+ return_type=return_type,
+ flags=pyobject_loop_flags,
+ locals=self.locals,
+ lifted=(),
+ lifted_from=self.lifted_from,
+ is_lifted_loop=True,)
+ # Check typing error if object mode is used
+ if (cres.typing_error is not None):
+ raise cres.typing_error
+ self.add_overload(cres)
+ return cres.entry_point
+
+
+class LiftedWith(LiftedCode):
+
+ can_cache = True
+
+ def _reduce_extras(self):
+ return dict(output_types=self.output_types)
+
+ @property
+ def _numba_type_(self):
+ return types.Dispatcher(self)
+
+ def get_call_template(self, args, kws):
+ """
+ Get a typing.ConcreteTemplate for this dispatcher and the given
+ *args* and *kws* types. This enables the resolving of the return type.
+
+ A (template, pysig, args, kws) tuple is returned.
+ """
+ # Ensure an overload is available
+ if self._can_compile:
+ self.compile(tuple(args))
+
+ pysig = None
+ # Create function type for typing
+ func_name = self.py_func.__name__
+ name = "CallTemplate({0})".format(func_name)
+ # The `key` isn't really used except for diagnosis here,
+ # so avoid keeping a reference to `cfunc`.
+ call_template = typing.make_concrete_template(
+ name, key=func_name, signatures=self.nopython_signatures)
+ return call_template, pysig, args, kws
+
+ def compile(self, sig):
+ # this is similar to LiftedLoop's compile but does not have the
+ # "fallback" to object mode part.
+ with ExitStack() as scope:
+ cres = None
+
+ def cb_compiler(dur):
+ if cres is not None:
+ self._callback_add_compiler_timer(dur, cres)
+
+ def cb_llvm(dur):
+ if cres is not None:
+ self._callback_add_llvm_timer(dur, cres)
+
+ scope.enter_context(ev.install_timer("numba:compiler_lock",
+ cb_compiler))
+ scope.enter_context(ev.install_timer("numba:llvm_lock", cb_llvm))
+ scope.enter_context(global_compiler_lock)
+
+ # Use counter to track recursion compilation depth
+ with self._compiling_counter:
+ # XXX this is mostly duplicated from Dispatcher.
+ flags = self.flags
+ args, return_type = sigutils.normalize_signature(sig)
+
+ # Don't recompile if signature already exists
+ # (e.g. if another thread compiled it before we got the lock)
+ existing = self.overloads.get(tuple(args))
+ if existing is not None:
+ return existing.entry_point
+
+ self._pre_compile(args, return_type, flags)
+
+ # Clone IR to avoid (some of the) mutation in the rewrite pass
+ cloned_func_ir = self.func_ir.copy()
+
+ ev_details = dict(
+ dispatcher=self,
+ args=args,
+ return_type=return_type,
+ )
+ with ev.trigger_event("numba:compile", data=ev_details):
+ cres = compiler.compile_ir(typingctx=self.typingctx,
+ targetctx=self.targetctx,
+ func_ir=cloned_func_ir,
+ args=args,
+ return_type=return_type,
+ flags=flags, locals=self.locals,
+ lifted=(),
+ lifted_from=self.lifted_from,
+ is_lifted_loop=True,)
+
+ # Check typing error if object mode is used
+ if (cres.typing_error is not None and
+ not flags.enable_pyobject):
+ raise cres.typing_error
+ self.add_overload(cres)
+ return cres.entry_point
+
+
+class ObjModeLiftedWith(LiftedWith):
+ def __init__(self, *args, **kwargs):
+ self.output_types = kwargs.pop('output_types', None)
+ super(LiftedWith, self).__init__(*args, **kwargs)
+ if not self.flags.force_pyobject:
+ raise ValueError("expecting `flags.force_pyobject`")
+ if self.output_types is None:
+ raise TypeError('`output_types` must be provided')
+ # switch off rewrites, they have no effect
+ self.flags.no_rewrites = True
+
+ @property
+ def _numba_type_(self):
+ return types.ObjModeDispatcher(self)
+
+ def get_call_template(self, args, kws):
+ """
+ Get a typing.ConcreteTemplate for this dispatcher and the given
+ *args* and *kws* types. This enables the resolving of the return type.
+
+ A (template, pysig, args, kws) tuple is returned.
+ """
+ assert not kws
+ self._legalize_arg_types(args)
+ # Coerce to object mode
+ args = [types.ffi_forced_object] * len(args)
+
+ if self._can_compile:
+ self.compile(tuple(args))
+
+ signatures = [typing.signature(self.output_types, *args)]
+ pysig = None
+ func_name = self.py_func.__name__
+ name = "CallTemplate({0})".format(func_name)
+ call_template = typing.make_concrete_template(
+ name, key=func_name, signatures=signatures)
+
+ return call_template, pysig, args, kws
+
+ def _legalize_arg_types(self, args):
+ for i, a in enumerate(args, start=1):
+ if isinstance(a, types.List):
+ msg = (
+ 'Does not support list type inputs into '
+ 'with-context for arg {}'
+ )
+ raise errors.TypingError(msg.format(i))
+ elif isinstance(a, types.Dispatcher):
+ msg = (
+ 'Does not support function type inputs into '
+ 'with-context for arg {}'
+ )
+ raise errors.TypingError(msg.format(i))
+
+ @global_compiler_lock
+ def compile(self, sig):
+ args, _ = sigutils.normalize_signature(sig)
+ sig = (types.ffi_forced_object,) * len(args)
+ return super().compile(sig)
+
+
+if config.USE_LEGACY_TYPE_SYSTEM: # Old type system
+ # Initialize typeof machinery
+ _dispatcher.typeof_init(
+ OmittedArg,
+ dict((str(t), t._code) for t in types.number_domain))
+else: # New type system
+ # Initialize typeof machinery
+ _dispatcher.typeof_init(
+ OmittedArg,
+ dict((str(t).split('_')[-1], t._code) for t in types.np_number_domain))
diff --git a/venv/lib/python3.10/site-packages/numba/core/entrypoints.py b/venv/lib/python3.10/site-packages/numba/core/entrypoints.py
new file mode 100644
index 0000000000000000000000000000000000000000..ceb0de4e3fcc66dfefa32d6c5b99752aac0f8757
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/entrypoints.py
@@ -0,0 +1,46 @@
+import logging
+import warnings
+
+from importlib import metadata as importlib_metadata
+
+
+_already_initialized = False
+logger = logging.getLogger(__name__)
+
+
+def init_all():
+ """Execute all `numba_extensions` entry points with the name `init`
+
+ If extensions have already been initialized, this function does nothing.
+ """
+ global _already_initialized
+ if _already_initialized:
+ return
+
+ # Must put this here to avoid extensions re-triggering initialization
+ _already_initialized = True
+
+ def load_ep(entry_point):
+ """Loads a given entry point. Warns and logs on failure.
+ """
+ logger.debug('Loading extension: %s', entry_point)
+ try:
+ func = entry_point.load()
+ func()
+ except Exception as e:
+ msg = (f"Numba extension module '{entry_point.module}' "
+ f"failed to load due to '{type(e).__name__}({str(e)})'.")
+ warnings.warn(msg, stacklevel=3)
+ logger.debug('Extension loading failed for: %s', entry_point)
+
+ eps = importlib_metadata.entry_points()
+ # Split, Python 3.10+ and importlib_metadata 3.6+ have the "selectable"
+ # interface, versions prior to that do not. See "compatibility note" in:
+ # https://docs.python.org/3.10/library/importlib.metadata.html#entry-points
+ if hasattr(eps, 'select'):
+ for entry_point in eps.select(group="numba_extensions", name="init"):
+ load_ep(entry_point)
+ else:
+ for entry_point in eps.get("numba_extensions", ()):
+ if entry_point.name == "init":
+ load_ep(entry_point)
diff --git a/venv/lib/python3.10/site-packages/numba/core/environment.py b/venv/lib/python3.10/site-packages/numba/core/environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffc5feb59defcbabc02fd96d728a94d307e84c4a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/environment.py
@@ -0,0 +1,64 @@
+import weakref
+import importlib
+
+from numba import _dynfunc
+
+
+class Environment(_dynfunc.Environment):
+ """Stores globals and constant pyobjects for runtime.
+
+ It is often needed to convert b/w nopython objects and pyobjects.
+ """
+ __slots__ = ('env_name', '__weakref__')
+ # A weak-value dictionary to store live environment with env_name as the
+ # key.
+ _memo = weakref.WeakValueDictionary()
+
+ @classmethod
+ def from_fndesc(cls, fndesc):
+ try:
+ # Avoid creating new Env
+ return cls._memo[fndesc.env_name]
+ except KeyError:
+ inst = cls(fndesc.lookup_globals())
+ inst.env_name = fndesc.env_name
+ cls._memo[fndesc.env_name] = inst
+ return inst
+
+ def can_cache(self):
+ is_dyn = '__name__' not in self.globals
+ return not is_dyn
+
+ def __reduce__(self):
+ return _rebuild_env, (
+ self.globals.get('__name__'),
+ self.consts,
+ self.env_name,
+ )
+
+ def __del__(self):
+ return
+
+ def __repr__(self):
+ return f""
+
+
+def _rebuild_env(modname, consts, env_name):
+ env = lookup_environment(env_name)
+ if env is not None:
+ return env
+
+ mod = importlib.import_module(modname)
+ env = Environment(mod.__dict__)
+ env.consts[:] = consts
+ env.env_name = env_name
+ # Cache loaded object
+ Environment._memo[env_name] = env
+ return env
+
+
+def lookup_environment(env_name):
+ """Returns the Environment object for the given name;
+ or None if not found
+ """
+ return Environment._memo.get(env_name)
diff --git a/venv/lib/python3.10/site-packages/numba/core/errors.py b/venv/lib/python3.10/site-packages/numba/core/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3cf6f4a413c4395bcfc0321028a23cec821ac94
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/errors.py
@@ -0,0 +1,867 @@
+"""
+Numba-specific errors and warnings.
+"""
+
+
+import abc
+import contextlib
+import os
+import warnings
+import numba.core.config
+import numpy as np
+from collections import defaultdict
+from functools import wraps
+from abc import abstractmethod
+
+# Filled at the end
+__all__ = []
+
+
+def _is_numba_core_config_loaded():
+ """
+ To detect if numba.core.config has been initialized due to circular imports.
+ """
+ try:
+ numba.core.config
+ except AttributeError:
+ return False
+ else:
+ return True
+
+
+class NumbaWarning(Warning):
+ """
+ Base category for all Numba compiler warnings.
+ """
+
+ def __init__(self, msg, loc=None, highlighting=True, ):
+ self.msg = msg
+ self.loc = loc
+
+ # If a warning is emitted inside validation of env-vars in
+ # numba.core.config. Highlighting will not be available.
+ if highlighting and _is_numba_core_config_loaded():
+ highlight = termcolor().errmsg
+ else:
+ def highlight(x):
+ return x
+ if loc:
+ super(NumbaWarning, self).__init__(
+ highlight("%s\n%s\n" % (msg, loc.strformat())))
+ else:
+ super(NumbaWarning, self).__init__(highlight("%s" % (msg,)))
+
+
+class NumbaPerformanceWarning(NumbaWarning):
+ """
+ Warning category for when an operation might not be
+ as fast as expected.
+ """
+
+
+class NumbaDeprecationWarning(NumbaWarning, DeprecationWarning):
+ """
+ Warning category for use of a deprecated feature.
+ """
+
+
+class NumbaPendingDeprecationWarning(NumbaWarning, PendingDeprecationWarning):
+ """
+ Warning category for use of a feature that is pending deprecation.
+ """
+
+
+class NumbaParallelSafetyWarning(NumbaWarning):
+ """
+ Warning category for when an operation in a prange
+ might not have parallel semantics.
+ """
+
+
+class NumbaTypeSafetyWarning(NumbaWarning):
+ """
+ Warning category for unsafe casting operations.
+ """
+
+
+class NumbaExperimentalFeatureWarning(NumbaWarning):
+ """
+ Warning category for using an experimental feature.
+ """
+
+
+class NumbaInvalidConfigWarning(NumbaWarning):
+ """
+ Warning category for using an invalid configuration.
+ """
+
+
+class NumbaPedanticWarning(NumbaWarning):
+ """
+ Warning category for reporting pedantic messages.
+ """
+ def __init__(self, msg, **kwargs):
+ super().__init__(f"{msg}\n{pedantic_warning_info}")
+
+
+class NumbaIRAssumptionWarning(NumbaPedanticWarning):
+ """
+ Warning category for reporting an IR assumption violation.
+ """
+
+
+class NumbaDebugInfoWarning(NumbaWarning):
+ """
+ Warning category for an issue with the emission of debug information.
+ """
+
+
+class NumbaSystemWarning(NumbaWarning):
+ """
+ Warning category for an issue with the system configuration.
+ """
+
+# These are needed in the color formatting of errors setup
+
+
+class _ColorScheme(metaclass=abc.ABCMeta):
+
+ @abstractmethod
+ def code(self, msg):
+ pass
+
+ @abstractmethod
+ def errmsg(self, msg):
+ pass
+
+ @abstractmethod
+ def filename(self, msg):
+ pass
+
+ @abstractmethod
+ def indicate(self, msg):
+ pass
+
+ @abstractmethod
+ def highlight(self, msg):
+ pass
+
+ @abstractmethod
+ def reset(self, msg):
+ pass
+
+
+class _DummyColorScheme(_ColorScheme):
+
+ def __init__(self, theme=None):
+ pass
+
+ def code(self, msg):
+ pass
+
+ def errmsg(self, msg):
+ pass
+
+ def filename(self, msg):
+ pass
+
+ def indicate(self, msg):
+ pass
+
+ def highlight(self, msg):
+ pass
+
+ def reset(self, msg):
+ pass
+
+
+# holds reference to the instance of the terminal color scheme in use
+_termcolor_inst = None
+
+try:
+ import colorama
+
+ # If the colorama version is < 0.3.9 it can break stdout/stderr in some
+ # situations, as a result if this condition is met colorama is disabled and
+ # the user is warned. Note that early versions did not have a __version__.
+ colorama_version = getattr(colorama, '__version__', '0.0.0')
+
+ if tuple([int(x) for x in colorama_version.split('.')]) < (0, 3, 9):
+ msg = ("Insufficiently recent colorama version found. "
+ "Numba requires colorama >= 0.3.9")
+ # warn the user
+ warnings.warn(msg)
+ # trip the exception to disable color errors
+ raise ImportError
+
+ # If Numba is running in testsuite mode then do not use error message
+ # coloring so CI system output is consistently readable without having
+ # to read between shell escape characters.
+ if os.environ.get('NUMBA_DISABLE_ERROR_MESSAGE_HIGHLIGHTING', None):
+ raise ImportError # just to trigger the exception handler below
+
+except ImportError:
+
+ class NOPColorScheme(_DummyColorScheme):
+ def __init__(self, theme=None):
+ if theme is not None:
+ raise ValueError("specifying a theme has no effect")
+ _DummyColorScheme.__init__(self, theme=theme)
+
+ def code(self, msg):
+ return msg
+
+ def errmsg(self, msg):
+ return msg
+
+ def filename(self, msg):
+ return msg
+
+ def indicate(self, msg):
+ return msg
+
+ def highlight(self, msg):
+ return msg
+
+ def reset(self, msg):
+ return msg
+
+ def termcolor():
+ global _termcolor_inst
+ if _termcolor_inst is None:
+ _termcolor_inst = NOPColorScheme()
+ return _termcolor_inst
+
+else:
+
+ from colorama import init, reinit, deinit, Fore, Style
+
+ class ColorShell(object):
+ _has_initialized = False
+
+ def __init__(self):
+ init()
+ self._has_initialized = True
+
+ def __enter__(self):
+ if self._has_initialized:
+ reinit()
+
+ def __exit__(self, *exc_detail):
+ Style.RESET_ALL
+ deinit()
+
+ class reset_terminal(object):
+ def __init__(self):
+ self._buf = bytearray(b'')
+
+ def __enter__(self):
+ return self._buf
+
+ def __exit__(self, *exc_detail):
+ self._buf += bytearray(Style.RESET_ALL.encode('utf-8'))
+
+ # define some default themes, if more are added, update the envvars docs!
+ themes = {}
+
+ # No color added, just bold weighting
+ themes['no_color'] = {'code': None,
+ 'errmsg': None,
+ 'filename': None,
+ 'indicate': None,
+ 'highlight': None,
+ 'reset': None, }
+
+ # suitable for terminals with a dark background
+ themes['dark_bg'] = {'code': Fore.BLUE,
+ 'errmsg': Fore.YELLOW,
+ 'filename': Fore.WHITE,
+ 'indicate': Fore.GREEN,
+ 'highlight': Fore.RED,
+ 'reset': Style.RESET_ALL, }
+
+ # suitable for terminals with a light background
+ themes['light_bg'] = {'code': Fore.BLUE,
+ 'errmsg': Fore.BLACK,
+ 'filename': Fore.MAGENTA,
+ 'indicate': Fore.BLACK,
+ 'highlight': Fore.RED,
+ 'reset': Style.RESET_ALL, }
+
+ # suitable for terminals with a blue background
+ themes['blue_bg'] = {'code': Fore.WHITE,
+ 'errmsg': Fore.YELLOW,
+ 'filename': Fore.MAGENTA,
+ 'indicate': Fore.CYAN,
+ 'highlight': Fore.RED,
+ 'reset': Style.RESET_ALL, }
+
+ # suitable for use in jupyter notebooks
+ themes['jupyter_nb'] = {'code': Fore.BLACK,
+ 'errmsg': Fore.BLACK,
+ 'filename': Fore.GREEN,
+ 'indicate': Fore.CYAN,
+ 'highlight': Fore.RED,
+ 'reset': Style.RESET_ALL, }
+
+ default_theme = themes['no_color']
+
+ class HighlightColorScheme(_DummyColorScheme):
+ def __init__(self, theme=default_theme):
+ self._code = theme['code']
+ self._errmsg = theme['errmsg']
+ self._filename = theme['filename']
+ self._indicate = theme['indicate']
+ self._highlight = theme['highlight']
+ self._reset = theme['reset']
+ _DummyColorScheme.__init__(self, theme=theme)
+
+ def _markup(self, msg, color=None, style=Style.BRIGHT):
+ features = ''
+ if color:
+ features += color
+ if style:
+ features += style
+ with ColorShell():
+ with reset_terminal() as mu:
+ mu += features.encode('utf-8')
+ mu += (msg).encode('utf-8')
+ return mu.decode('utf-8')
+
+ def code(self, msg):
+ return self._markup(msg, self._code)
+
+ def errmsg(self, msg):
+ return self._markup(msg, self._errmsg)
+
+ def filename(self, msg):
+ return self._markup(msg, self._filename)
+
+ def indicate(self, msg):
+ return self._markup(msg, self._indicate)
+
+ def highlight(self, msg):
+ return self._markup(msg, self._highlight)
+
+ def reset(self, msg):
+ return self._markup(msg, self._reset)
+
+ def termcolor():
+ global _termcolor_inst
+ if _termcolor_inst is None:
+ scheme = themes[numba.core.config.COLOR_SCHEME]
+ _termcolor_inst = HighlightColorScheme(scheme)
+ return _termcolor_inst
+
+
+pedantic_warning_info = """
+This warning came from an internal pedantic check. Please report the warning
+message and traceback, along with a minimal reproducer at:
+https://github.com/numba/numba/issues/new?template=bug_report.md
+"""
+
+feedback_details = """
+Please report the error message and traceback, along with a minimal reproducer
+at: https://github.com/numba/numba/issues/new?template=bug_report.md
+
+If more help is needed please feel free to speak to the Numba core developers
+directly at: https://gitter.im/numba/numba
+
+Thanks in advance for your help in improving Numba!
+"""
+
+unsupported_error_info = """
+Unsupported functionality was found in the code Numba was trying to compile.
+
+If this functionality is important to you please file a feature request at:
+https://github.com/numba/numba/issues/new?template=feature_request.md
+"""
+
+interpreter_error_info = """
+Unsupported Python functionality was found in the code Numba was trying to
+compile. This error could be due to invalid code, does the code work
+without Numba? (To temporarily disable Numba JIT, set the `NUMBA_DISABLE_JIT`
+environment variable to non-zero, and then rerun the code).
+
+If the code is valid and the unsupported functionality is important to you
+please file a feature request at:
+https://github.com/numba/numba/issues/new?template=feature_request.md
+
+To see Python/NumPy features supported by the latest release of Numba visit:
+https://numba.readthedocs.io/en/stable/reference/pysupported.html
+and
+https://numba.readthedocs.io/en/stable/reference/numpysupported.html
+"""
+
+constant_inference_info = """
+Numba could not make a constant out of something that it decided should be
+a constant. This could well be a current limitation in Numba's internals,
+however please first check that your code is valid for compilation,
+particularly with respect to string interpolation (not supported!) and
+the requirement of compile time constants as arguments to exceptions:
+https://numba.readthedocs.io/en/stable/reference/pysupported.html?highlight=exceptions#constructs
+
+If the code is valid and the unsupported functionality is important to you
+please file a feature request at:
+https://github.com/numba/numba/issues/new?template=feature_request.md
+
+If you think your code should work with Numba. %s
+""" % feedback_details
+
+typing_error_info = """
+This is not usually a problem with Numba itself but instead often caused by
+the use of unsupported features or an issue in resolving types.
+
+To see Python/NumPy features supported by the latest release of Numba visit:
+https://numba.readthedocs.io/en/stable/reference/pysupported.html
+and
+https://numba.readthedocs.io/en/stable/reference/numpysupported.html
+
+For more information about typing errors and how to debug them visit:
+https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-doesn-t-compile
+
+If you think your code should work with Numba, please report the error message
+and traceback, along with a minimal reproducer at:
+https://github.com/numba/numba/issues/new?template=bug_report.md
+"""
+
+reportable_issue_info = """
+-------------------------------------------------------------------------------
+This should not have happened, a problem has occurred in Numba's internals.
+You are currently using Numba version %s.
+%s
+""" % (numba.__version__, feedback_details)
+
+error_extras = dict()
+error_extras['unsupported_error'] = unsupported_error_info
+error_extras['typing'] = typing_error_info
+error_extras['reportable'] = reportable_issue_info
+error_extras['interpreter'] = interpreter_error_info
+error_extras['constant_inference'] = constant_inference_info
+
+
+def deprecated(arg):
+ """Define a deprecation decorator.
+ An optional string should refer to the new API to be used instead.
+
+ Example:
+ @deprecated
+ def old_func(): ...
+
+ @deprecated('new_func')
+ def old_func(): ..."""
+
+ subst = arg if isinstance(arg, str) else None
+
+ def decorator(func):
+ def wrapper(*args, **kwargs):
+ msg = "Call to deprecated function \"{}\"."
+ if subst:
+ msg += "\n Use \"{}\" instead."
+ warnings.warn(msg.format(func.__name__, subst),
+ category=DeprecationWarning, stacklevel=2)
+ return func(*args, **kwargs)
+
+ return wraps(func)(wrapper)
+
+ if not subst:
+ return decorator(arg)
+ else:
+ return decorator
+
+
+class WarningsFixer(object):
+ """
+ An object "fixing" warnings of a given category caught during
+ certain phases. The warnings can have their filename and lineno fixed,
+ and they are deduplicated as well.
+
+ When used as a context manager, any warnings caught by `.catch_warnings()`
+ will be flushed at the exit of the context manager.
+ """
+
+ def __init__(self, category):
+ self._category = category
+ # {(filename, lineno, category) -> messages}
+ self._warnings = defaultdict(set)
+
+ @contextlib.contextmanager
+ def catch_warnings(self, filename=None, lineno=None):
+ """
+ Store warnings and optionally fix their filename and lineno.
+ """
+ with warnings.catch_warnings(record=True) as wlist:
+ warnings.simplefilter('always', self._category)
+ yield
+
+ for w in wlist:
+ msg = str(w.message)
+ if issubclass(w.category, self._category):
+ # Store warnings of this category for deduplication
+ filename = filename or w.filename
+ lineno = lineno or w.lineno
+ self._warnings[filename, lineno, w.category].add(msg)
+ else:
+ # Simply emit other warnings again
+ warnings.warn_explicit(msg, w.category,
+ w.filename, w.lineno)
+
+ def flush(self):
+ """
+ Emit all stored warnings.
+ """
+ def key(arg):
+ # It is possible through codegen to create entirely identical
+ # warnings, this leads to comparing types when sorting which breaks
+ # on Python 3. Key as str() and if the worse happens then `id`
+ # creates some uniqueness
+ return str(arg) + str(id(arg))
+
+ for (filename, lineno, category), messages in sorted(
+ self._warnings.items(), key=key):
+ for msg in sorted(messages):
+ warnings.warn_explicit(msg, category, filename, lineno)
+ self._warnings.clear()
+
+ def __enter__(self):
+ return
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ self.flush()
+
+
+class NumbaError(Exception):
+ def __init__(self, msg, loc=None, highlighting=True):
+ self.msg = msg
+ self.loc = loc
+ if highlighting:
+ highlight = termcolor().errmsg
+ else:
+ def highlight(x):
+ return x
+
+ if loc:
+ new_msg = "%s\n%s\n" % (msg, loc.strformat())
+ else:
+ new_msg = "%s" % (msg,)
+ super(NumbaError, self).__init__(highlight(new_msg))
+
+ @property
+ def contexts(self):
+ try:
+ return self._contexts
+ except AttributeError:
+ self._contexts = lst = []
+ return lst
+
+ def add_context(self, msg):
+ """
+ Add contextual info. The exception message is expanded with the new
+ contextual information.
+ """
+ self.contexts.append(msg)
+ f = termcolor().errmsg('{0}\n') + termcolor().filename('During: {1}')
+ newmsg = f.format(self, msg)
+ self.args = (newmsg,)
+ return self
+
+ def patch_message(self, new_message):
+ """
+ Change the error message to the given new message.
+ """
+ self.args = (new_message,) + self.args[1:]
+
+
+class UnsupportedError(NumbaError):
+ """
+ Numba does not have an implementation for this functionality.
+ """
+
+
+class UnsupportedBytecodeError(Exception):
+ """Unsupported bytecode is non-recoverable
+ """
+ def __init__(self, msg, loc=None):
+ super().__init__(f"{msg}. Raised from {loc}")
+
+
+class UnsupportedRewriteError(UnsupportedError):
+ """UnsupportedError from rewrite passes
+ """
+ pass
+
+
+class IRError(NumbaError):
+ """
+ An error occurred during Numba IR generation.
+ """
+ pass
+
+
+class RedefinedError(IRError):
+ """
+ An error occurred during interpretation of IR due to variable redefinition.
+ """
+ pass
+
+
+class NotDefinedError(IRError):
+ """
+ An undefined variable is encountered during interpretation of IR.
+ """
+
+ def __init__(self, name, loc=None):
+ self.name = name
+ msg = ("The compiler failed to analyze the bytecode. "
+ "Variable '%s' is not defined." % name)
+ super(NotDefinedError, self).__init__(msg, loc=loc)
+
+
+class VerificationError(IRError):
+ """
+ An error occurred during IR verification. Once Numba's internal
+ representation (IR) is constructed it is then verified to ensure that
+ terminators are both present and in the correct places within the IR. If
+ it is the case that this condition is not met, a VerificationError is
+ raised.
+ """
+ pass
+
+
+class DeprecationError(NumbaError):
+ """
+ Functionality is deprecated.
+ """
+ pass
+
+
+class LoweringError(NumbaError):
+ """
+ An error occurred during lowering.
+ """
+
+ def __init__(self, msg, loc=None):
+ super(LoweringError, self).__init__(msg, loc=loc)
+
+
+class UnsupportedParforsError(NumbaError):
+ """
+ An error occurred because parfors is not supported on the platform.
+ """
+ pass
+
+
+class ForbiddenConstruct(LoweringError):
+ """
+ A forbidden Python construct was encountered (e.g. use of locals()).
+ """
+ pass
+
+
+class TypingError(NumbaError):
+ """
+ A type inference failure.
+ """
+ pass
+
+
+class UntypedAttributeError(TypingError):
+ def __init__(self, value, attr, loc=None):
+ module = getattr(value, 'pymod', None)
+ if module is not None and module == np:
+ # unsupported numpy feature.
+ msg = ("Use of unsupported NumPy function 'numpy.%s' "
+ "or unsupported use of the function.") % attr
+ else:
+ msg = "Unknown attribute '{attr}' of type {type}"
+ msg = msg.format(type=value, attr=attr)
+ super(UntypedAttributeError, self).__init__(msg, loc=loc)
+
+
+class ByteCodeSupportError(NumbaError):
+ """
+ Failure to extract the bytecode of the user's function.
+ """
+
+ def __init__(self, msg, loc=None):
+ super(ByteCodeSupportError, self).__init__(msg, loc=loc)
+
+
+class CompilerError(NumbaError):
+ """
+ Some high-level error in the compiler.
+ """
+ pass
+
+
+class ConstantInferenceError(NumbaError):
+ """
+ Failure during constant inference.
+ """
+
+ def __init__(self, value, loc=None):
+ super(ConstantInferenceError, self).__init__(value, loc=loc)
+
+
+class InternalError(NumbaError):
+ """
+ For wrapping internal error occurred within the compiler
+ """
+
+ def __init__(self, exception):
+ super(InternalError, self).__init__(str(exception))
+ self.old_exception = exception
+
+
+class InternalTargetMismatchError(InternalError):
+ """For signalling a target mismatch error occurred internally within the
+ compiler.
+ """
+ def __init__(self, kind, target_hw, hw_clazz):
+ msg = (f"{kind.title()} being resolved on a target from which it does "
+ f"not inherit. Local target is {target_hw}, declared "
+ f"target class is {hw_clazz}.")
+ super().__init__(msg)
+
+
+class NonexistentTargetError(InternalError):
+ """For signalling that a target that does not exist was requested.
+ """
+ pass
+
+
+class RequireLiteralValue(TypingError):
+ """
+ For signalling that a function's typing requires a constant value for
+ some of its arguments.
+ """
+ pass
+
+
+class ForceLiteralArg(NumbaError):
+ """A Pseudo-exception to signal the dispatcher to type an argument literally
+
+ Attributes
+ ----------
+ requested_args : frozenset[int]
+ requested positions of the arguments.
+ """
+ def __init__(self, arg_indices, fold_arguments=None, loc=None):
+ """
+ Parameters
+ ----------
+ arg_indices : Sequence[int]
+ requested positions of the arguments.
+ fold_arguments: callable
+ A function ``(tuple, dict) -> tuple`` that binds and flattens
+ the ``args`` and ``kwargs``.
+ loc : numba.ir.Loc or None
+ """
+ super(ForceLiteralArg, self).__init__(
+ "Pseudo-exception to force literal arguments in the dispatcher",
+ loc=loc,
+ )
+ self.requested_args = frozenset(arg_indices)
+ self.fold_arguments = fold_arguments
+
+ def bind_fold_arguments(self, fold_arguments):
+ """Bind the fold_arguments function
+ """
+ # to avoid circular import
+ from numba.core.utils import chain_exception
+
+ e = ForceLiteralArg(self.requested_args, fold_arguments,
+ loc=self.loc)
+ return chain_exception(e, self)
+
+ def combine(self, other):
+ """Returns a new instance by or'ing the requested_args.
+ """
+ if not isinstance(other, ForceLiteralArg):
+ m = '*other* must be a {} but got a {} instead'
+ raise TypeError(m.format(ForceLiteralArg, type(other)))
+ return ForceLiteralArg(self.requested_args | other.requested_args)
+
+ def __or__(self, other):
+ """Same as self.combine(other)
+ """
+ return self.combine(other)
+
+
+class LiteralTypingError(TypingError):
+ """
+ Failure in typing a Literal type
+ """
+ pass
+
+
+# These Exception classes are just Numba copies of their Python equivalents for
+# use internally in cases where we want e.g. type inference to keep on trying.
+# Exceptions extending from NumbaError are considered "special" by Numba's
+# internals and are treated differently to standard Python exceptions which are
+# permitted to just propagate up the stack.
+
+class NumbaValueError(TypingError):
+ pass
+
+
+class NumbaTypeError(TypingError):
+ pass
+
+
+class NumbaAttributeError(TypingError):
+ pass
+
+
+class NumbaAssertionError(TypingError):
+ pass
+
+
+class NumbaNotImplementedError(TypingError):
+ pass
+
+
+class NumbaKeyError(TypingError):
+ pass
+
+
+class NumbaIndexError(TypingError):
+ pass
+
+
+class NumbaRuntimeError(NumbaError):
+ pass
+
+
+def _format_msg(fmt, args, kwargs):
+ return fmt.format(*args, **kwargs)
+
+
+_numba_path = os.path.dirname(__file__)
+loc_info = {}
+
+
+@contextlib.contextmanager
+def new_error_context(fmt_, *args, **kwargs):
+ """
+ A contextmanager that prepend contextual information to any exception
+ raised within.
+
+ The first argument is a message that describes the context. It can be a
+ format string. If there are additional arguments, it will be used as
+ ``fmt_.format(*args, **kwargs)`` to produce the final message string.
+ """
+ loc = kwargs.get('loc', None)
+ if loc is not None and not loc.filename.startswith(_numba_path):
+ loc_info.update(kwargs)
+
+ try:
+ yield
+ except NumbaError as e:
+ e.add_context(_format_msg(fmt_, args, kwargs))
+ raise
+
+
+__all__ += [name for (name, value) in globals().items()
+ if not name.startswith('_') and isinstance(value, type)
+ and issubclass(value, (Exception, Warning))]
diff --git a/venv/lib/python3.10/site-packages/numba/core/event.py b/venv/lib/python3.10/site-packages/numba/core/event.py
new file mode 100644
index 0000000000000000000000000000000000000000..7190db75b28454ede95bcac9de7e4a504209ba86
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/event.py
@@ -0,0 +1,485 @@
+"""
+The ``numba.core.event`` module provides a simple event system for applications
+to register callbacks to listen to specific compiler events.
+
+The following events are built in:
+
+- ``"numba:compile"`` is broadcast when a dispatcher is compiling. Events of
+ this kind have ``data`` defined to be a ``dict`` with the following
+ key-values:
+
+ - ``"dispatcher"``: the dispatcher object that is compiling.
+ - ``"args"``: the argument types.
+ - ``"return_type"``: the return type.
+
+- ``"numba:compiler_lock"`` is broadcast when the internal compiler-lock is
+ acquired. This is mostly used internally to measure time spent with the lock
+ acquired.
+
+- ``"numba:llvm_lock"`` is broadcast when the internal LLVM-lock is acquired.
+ This is used internally to measure time spent with the lock acquired.
+
+- ``"numba:run_pass"`` is broadcast when a compiler pass is running.
+
+ - ``"name"``: pass name.
+ - ``"qualname"``: qualified name of the function being compiled.
+ - ``"module"``: module name of the function being compiled.
+ - ``"flags"``: compilation flags.
+ - ``"args"``: argument types.
+ - ``"return_type"`` return type.
+
+Applications can register callbacks that are listening for specific events using
+``register(kind: str, listener: Listener)``, where ``listener`` is an instance
+of ``Listener`` that defines custom actions on occurrence of the specific event.
+"""
+
+import os
+import json
+import atexit
+import abc
+import enum
+import time
+import threading
+from timeit import default_timer as timer
+from contextlib import contextmanager, ExitStack
+from collections import defaultdict
+
+from numba.core import config, utils
+
+
+class EventStatus(enum.Enum):
+ """Status of an event.
+ """
+ START = enum.auto()
+ END = enum.auto()
+
+
+# Builtin event kinds.
+_builtin_kinds = frozenset([
+ "numba:compiler_lock",
+ "numba:compile",
+ "numba:llvm_lock",
+ "numba:run_pass",
+])
+
+
+def _guard_kind(kind):
+ """Guard to ensure that an event kind is valid.
+
+ All event kinds with a "numba:" prefix must be defined in the pre-defined
+ ``numba.core.event._builtin_kinds``.
+ Custom event kinds are allowed by not using the above prefix.
+
+ Parameters
+ ----------
+ kind : str
+
+ Return
+ ------
+ res : str
+ """
+ if kind.startswith("numba:") and kind not in _builtin_kinds:
+ msg = (f"{kind} is not a valid event kind, "
+ "it starts with the reserved prefix 'numba:'")
+ raise ValueError(msg)
+ return kind
+
+
+class Event:
+ """An event.
+
+ Parameters
+ ----------
+ kind : str
+ status : EventStatus
+ data : any; optional
+ Additional data for the event.
+ exc_details : 3-tuple; optional
+ Same 3-tuple for ``__exit__``.
+ """
+ def __init__(self, kind, status, data=None, exc_details=None):
+ self._kind = _guard_kind(kind)
+ self._status = status
+ self._data = data
+ self._exc_details = (None
+ if exc_details is None or exc_details[0] is None
+ else exc_details)
+
+ @property
+ def kind(self):
+ """Event kind
+
+ Returns
+ -------
+ res : str
+ """
+ return self._kind
+
+ @property
+ def status(self):
+ """Event status
+
+ Returns
+ -------
+ res : EventStatus
+ """
+ return self._status
+
+ @property
+ def data(self):
+ """Event data
+
+ Returns
+ -------
+ res : object
+ """
+ return self._data
+
+ @property
+ def is_start(self):
+ """Is it a *START* event?
+
+ Returns
+ -------
+ res : bool
+ """
+ return self._status == EventStatus.START
+
+ @property
+ def is_end(self):
+ """Is it an *END* event?
+
+ Returns
+ -------
+ res : bool
+ """
+ return self._status == EventStatus.END
+
+ @property
+ def is_failed(self):
+ """Is the event carrying an exception?
+
+ This is used for *END* event. This method will never return ``True``
+ in a *START* event.
+
+ Returns
+ -------
+ res : bool
+ """
+ return self._exc_details is None
+
+ def __str__(self):
+ data = (f"{type(self.data).__qualname__}"
+ if self.data is not None else "None")
+ return f"Event({self._kind}, {self._status}, data: {data})"
+
+ __repr__ = __str__
+
+
+_registered = defaultdict(list)
+
+
+def register(kind, listener):
+ """Register a listener for a given event kind.
+
+ Parameters
+ ----------
+ kind : str
+ listener : Listener
+ """
+ assert isinstance(listener, Listener)
+ kind = _guard_kind(kind)
+ _registered[kind].append(listener)
+
+
+def unregister(kind, listener):
+ """Unregister a listener for a given event kind.
+
+ Parameters
+ ----------
+ kind : str
+ listener : Listener
+ """
+ assert isinstance(listener, Listener)
+ kind = _guard_kind(kind)
+ lst = _registered[kind]
+ lst.remove(listener)
+
+
+def broadcast(event):
+ """Broadcast an event to all registered listeners.
+
+ Parameters
+ ----------
+ event : Event
+ """
+ for listener in _registered[event.kind]:
+ listener.notify(event)
+
+
+class Listener(abc.ABC):
+ """Base class for all event listeners.
+ """
+ @abc.abstractmethod
+ def on_start(self, event):
+ """Called when there is a *START* event.
+
+ Parameters
+ ----------
+ event : Event
+ """
+ pass
+
+ @abc.abstractmethod
+ def on_end(self, event):
+ """Called when there is a *END* event.
+
+ Parameters
+ ----------
+ event : Event
+ """
+ pass
+
+ def notify(self, event):
+ """Notify this Listener with the given Event.
+
+ Parameters
+ ----------
+ event : Event
+ """
+ if event.is_start:
+ self.on_start(event)
+ elif event.is_end:
+ self.on_end(event)
+ else:
+ raise AssertionError("unreachable")
+
+
+class TimingListener(Listener):
+ """A listener that measures the total time spent between *START* and
+ *END* events during the time this listener is active.
+ """
+ def __init__(self):
+ self._depth = 0
+
+ def on_start(self, event):
+ if self._depth == 0:
+ self._ts = timer()
+ self._depth += 1
+
+ def on_end(self, event):
+ self._depth -= 1
+ if self._depth == 0:
+ last = getattr(self, "_duration", 0)
+ self._duration = (timer() - self._ts) + last
+
+ @property
+ def done(self):
+ """Returns a ``bool`` indicating whether a measurement has been made.
+
+ When this returns ``False``, the matching event has never fired.
+ If and only if this returns ``True``, ``.duration`` can be read without
+ error.
+ """
+ return hasattr(self, "_duration")
+
+ @property
+ def duration(self):
+ """Returns the measured duration.
+
+ This may raise ``AttributeError``. Users can use ``.done`` to check
+ that a measurement has been made.
+ """
+ return self._duration
+
+
+class RecordingListener(Listener):
+ """A listener that records all events and stores them in the ``.buffer``
+ attribute as a list of 2-tuple ``(float, Event)``, where the first element
+ is the time the event occurred as returned by ``time.time()`` and the second
+ element is the event.
+ """
+ def __init__(self):
+ self.buffer = []
+
+ def on_start(self, event):
+ self.buffer.append((time.time(), event))
+
+ def on_end(self, event):
+ self.buffer.append((time.time(), event))
+
+
+@contextmanager
+def install_listener(kind, listener):
+ """Install a listener for event "kind" temporarily within the duration of
+ the context.
+
+ Returns
+ -------
+ res : Listener
+ The *listener* provided.
+
+ Examples
+ --------
+
+ >>> with install_listener("numba:compile", listener):
+ >>> some_code() # listener will be active here.
+ >>> other_code() # listener will be unregistered by this point.
+
+ """
+ register(kind, listener)
+ try:
+ yield listener
+ finally:
+ unregister(kind, listener)
+
+
+@contextmanager
+def install_timer(kind, callback):
+ """Install a TimingListener temporarily to measure the duration of
+ an event.
+
+ If the context completes successfully, the *callback* function is executed.
+ The *callback* function is expected to take a float argument for the
+ duration in seconds.
+
+ Returns
+ -------
+ res : TimingListener
+
+ Examples
+ --------
+
+ This is equivalent to:
+
+ >>> with install_listener(kind, TimingListener()) as res:
+ >>> ...
+ """
+ tl = TimingListener()
+ with install_listener(kind, tl):
+ yield tl
+
+ if tl.done:
+ callback(tl.duration)
+
+
+@contextmanager
+def install_recorder(kind):
+ """Install a RecordingListener temporarily to record all events.
+
+ Once the context is closed, users can use ``RecordingListener.buffer``
+ to access the recorded events.
+
+ Returns
+ -------
+ res : RecordingListener
+
+ Examples
+ --------
+
+ This is equivalent to:
+
+ >>> with install_listener(kind, RecordingListener()) as res:
+ >>> ...
+ """
+ rl = RecordingListener()
+ with install_listener(kind, rl):
+ yield rl
+
+
+def start_event(kind, data=None):
+ """Trigger the start of an event of *kind* with *data*.
+
+ Parameters
+ ----------
+ kind : str
+ Event kind.
+ data : any; optional
+ Extra event data.
+ """
+ evt = Event(kind=kind, status=EventStatus.START, data=data)
+ broadcast(evt)
+
+
+def end_event(kind, data=None, exc_details=None):
+ """Trigger the end of an event of *kind*, *exc_details*.
+
+ Parameters
+ ----------
+ kind : str
+ Event kind.
+ data : any; optional
+ Extra event data.
+ exc_details : 3-tuple; optional
+ Same 3-tuple for ``__exit__``. Or, ``None`` if no error.
+ """
+ evt = Event(
+ kind=kind, status=EventStatus.END, data=data, exc_details=exc_details,
+ )
+ broadcast(evt)
+
+
+@contextmanager
+def trigger_event(kind, data=None):
+ """A context manager to trigger the start and end events of *kind* with
+ *data*. The start event is triggered when entering the context.
+ The end event is triggered when exiting the context.
+
+ Parameters
+ ----------
+ kind : str
+ Event kind.
+ data : any; optional
+ Extra event data.
+ """
+ with ExitStack() as scope:
+ @scope.push
+ def on_exit(*exc_details):
+ end_event(kind, data=data, exc_details=exc_details)
+
+ start_event(kind, data=data)
+ yield
+
+
+def _prepare_chrome_trace_data(listener: RecordingListener):
+ """Prepare events in `listener` for serializing as chrome trace data.
+ """
+ # The spec for the trace event format can be found at:
+ # https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/edit # noqa
+ # This code only uses the JSON Array Format for simplicity.
+ pid = os.getpid()
+ tid = threading.get_native_id()
+ evs = []
+ for ts, rec in listener.buffer:
+ data = rec.data
+ cat = str(rec.kind)
+ ts_scaled = ts * 1_000_000 # scale to microseconds
+ ph = 'B' if rec.is_start else 'E'
+ name = data['name']
+ args = data
+ ev = dict(
+ cat=cat, pid=pid, tid=tid, ts=ts_scaled, ph=ph, name=name,
+ args=args,
+ )
+ evs.append(ev)
+ return evs
+
+
+def _setup_chrome_trace_exit_handler():
+ """Setup a RecordingListener and an exit handler to write the captured
+ events to file.
+ """
+ listener = RecordingListener()
+ register("numba:run_pass", listener)
+ filename = config.CHROME_TRACE
+
+ @atexit.register
+ def _write_chrome_trace():
+ # The following output file is not multi-process safe.
+ evs = _prepare_chrome_trace_data(listener)
+ with open(filename, "w") as out:
+ json.dump(evs, out, cls=utils._LazyJSONEncoder)
+
+
+if config.CHROME_TRACE:
+ _setup_chrome_trace_exit_handler()
diff --git a/venv/lib/python3.10/site-packages/numba/core/extending.py b/venv/lib/python3.10/site-packages/numba/core/extending.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4da9109988124024b6a8e7d30f733026bf764bd
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/extending.py
@@ -0,0 +1,587 @@
+import os
+import uuid
+import weakref
+import collections
+import functools
+
+import numba
+from numba.core import types, errors, utils, config
+
+# Exported symbols
+from numba.core.typing.typeof import typeof_impl # noqa: F401
+from numba.core.typing.asnumbatype import as_numba_type # noqa: F401
+from numba.core.typing.templates import infer, infer_getattr # noqa: F401
+from numba.core.imputils import ( # noqa: F401
+ lower_builtin, lower_getattr, lower_getattr_generic, # noqa: F401
+ lower_setattr, lower_setattr_generic, lower_cast) # noqa: F401
+from numba.core.datamodel import models # noqa: F401
+from numba.core.datamodel import register_default as register_model # noqa: F401, E501
+from numba.core.pythonapi import box, unbox, reflect, NativeValue # noqa: F401
+from numba._helperlib import _import_cython_function # noqa: F401
+from numba.core.serialize import ReduceMixin
+
+
+def type_callable(func):
+ """
+ Decorate a function as implementing typing for the callable *func*.
+ *func* can be a callable object (probably a global) or a string
+ denoting a built-in operation (such 'getitem' or '__array_wrap__')
+ """
+ from numba.core.typing.templates import (CallableTemplate, infer,
+ infer_global)
+ if not callable(func) and not isinstance(func, str):
+ raise TypeError("`func` should be a function or string")
+ try:
+ func_name = func.__name__
+ except AttributeError:
+ func_name = str(func)
+
+ def decorate(typing_func):
+ def generic(self):
+ return typing_func(self.context)
+
+ name = "%s_CallableTemplate" % (func_name,)
+ bases = (CallableTemplate,)
+ class_dict = dict(key=func, generic=generic)
+ template = type(name, bases, class_dict)
+ infer(template)
+ if callable(func):
+ infer_global(func, types.Function(template))
+ return typing_func
+
+ return decorate
+
+
+# By default, an *overload* does not have a cpython wrapper because it is not
+# callable from python. It also has `nopython=True`, this has been default since
+# its inception!
+_overload_default_jit_options = {'no_cpython_wrapper': True,
+ 'nopython':True}
+
+
+def overload(func, jit_options={}, strict=True, inline='never',
+ prefer_literal=False, **kwargs):
+ """
+ A decorator marking the decorated function as typing and implementing
+ *func* in nopython mode.
+
+ The decorated function will have the same formal parameters as *func*
+ and be passed the Numba types of those parameters. It should return
+ a function implementing *func* for the given types.
+
+ Here is an example implementing len() for tuple types::
+
+ @overload(len)
+ def tuple_len(seq):
+ if isinstance(seq, types.BaseTuple):
+ n = len(seq)
+ def len_impl(seq):
+ return n
+ return len_impl
+
+ Compiler options can be passed as an dictionary using the **jit_options**
+ argument.
+
+ Overloading strictness (that the typing and implementing signatures match)
+ is enforced by the **strict** keyword argument, it is recommended that this
+ is set to True (default).
+
+ To handle a function that accepts imprecise types, an overload
+ definition can return 2-tuple of ``(signature, impl_function)``, where
+ the ``signature`` is a ``typing.Signature`` specifying the precise
+ signature to be used; and ``impl_function`` is the same implementation
+ function as in the simple case.
+
+ If the kwarg inline determines whether the overload is inlined in the
+ calling function and can be one of three values:
+ * 'never' (default) - the overload is never inlined.
+ * 'always' - the overload is always inlined.
+ * a function that takes two arguments, both of which are instances of a
+ namedtuple with fields:
+ * func_ir
+ * typemap
+ * calltypes
+ * signature
+ The first argument holds the information from the caller, the second
+ holds the information from the callee. The function should return Truthy
+ to determine whether to inline, this essentially permitting custom
+ inlining rules (typical use might be cost models).
+
+ The *prefer_literal* option allows users to control if literal types should
+ be tried first or last. The default (`False`) is to use non-literal types.
+ Implementations that can specialize based on literal values should set the
+ option to `True`. Note, this option maybe expanded in the near future to
+ allow for more control (e.g. disabling non-literal types).
+
+ **kwargs prescribes additional arguments passed through to the overload
+ template. The only accepted key at present is 'target' which is a string
+ corresponding to the target that this overload should be bound against.
+ """
+ from numba.core.typing.templates import make_overload_template, infer_global
+
+ # set default options
+ opts = _overload_default_jit_options.copy()
+ opts.update(jit_options) # let user options override
+
+ # TODO: abort now if the kwarg 'target' relates to an unregistered target,
+ # this requires sorting out the circular imports first.
+
+ def decorate(overload_func):
+ template = make_overload_template(func, overload_func, opts, strict,
+ inline, prefer_literal, **kwargs)
+ infer(template)
+ if callable(func):
+ infer_global(func, types.Function(template))
+ return overload_func
+
+ return decorate
+
+
+def register_jitable(*args, **kwargs):
+ """
+ Register a regular python function that can be executed by the python
+ interpreter and can be compiled into a nopython function when referenced
+ by other jit'ed functions. Can be used as::
+
+ @register_jitable
+ def foo(x, y):
+ return x + y
+
+ Or, with compiler options::
+
+ @register_jitable(_nrt=False) # disable runtime allocation
+ def foo(x, y):
+ return x + y
+
+ """
+ def wrap(fn):
+ # It is just a wrapper for @overload
+ inline = kwargs.pop('inline', 'never')
+
+ @overload(fn, jit_options=kwargs, inline=inline, strict=False)
+ def ov_wrap(*args, **kwargs):
+ return fn
+ return fn
+
+ if kwargs:
+ return wrap
+ else:
+ return wrap(*args)
+
+
+def overload_attribute(typ, attr, **kwargs):
+ """
+ A decorator marking the decorated function as typing and implementing
+ attribute *attr* for the given Numba type in nopython mode.
+
+ *kwargs* are passed to the underlying `@overload` call.
+
+ Here is an example implementing .nbytes for array types::
+
+ @overload_attribute(types.Array, 'nbytes')
+ def array_nbytes(arr):
+ def get(arr):
+ return arr.size * arr.itemsize
+ return get
+ """
+ # TODO implement setters
+ from numba.core.typing.templates import make_overload_attribute_template
+
+ def decorate(overload_func):
+ template = make_overload_attribute_template(
+ typ, attr, overload_func,
+ **kwargs
+ )
+ infer_getattr(template)
+ overload(overload_func, **kwargs)(overload_func)
+ return overload_func
+
+ return decorate
+
+
+def _overload_method_common(typ, attr, **kwargs):
+ """Common code for overload_method and overload_classmethod
+ """
+ from numba.core.typing.templates import make_overload_method_template
+
+ def decorate(overload_func):
+ copied_kwargs = kwargs.copy() # avoid mutating parent dict
+ template = make_overload_method_template(
+ typ, attr, overload_func,
+ inline=copied_kwargs.pop('inline', 'never'),
+ prefer_literal=copied_kwargs.pop('prefer_literal', False),
+ **copied_kwargs,
+ )
+ infer_getattr(template)
+ overload(overload_func, **kwargs)(overload_func)
+ return overload_func
+
+ return decorate
+
+
+def overload_method(typ, attr, **kwargs):
+ """
+ A decorator marking the decorated function as typing and implementing
+ method *attr* for the given Numba type in nopython mode.
+
+ *kwargs* are passed to the underlying `@overload` call.
+
+ Here is an example implementing .take() for array types::
+
+ @overload_method(types.Array, 'take')
+ def array_take(arr, indices):
+ if isinstance(indices, types.Array):
+ def take_impl(arr, indices):
+ n = indices.shape[0]
+ res = np.empty(n, arr.dtype)
+ for i in range(n):
+ res[i] = arr[indices[i]]
+ return res
+ return take_impl
+ """
+ return _overload_method_common(typ, attr, **kwargs)
+
+
+def overload_classmethod(typ, attr, **kwargs):
+ """
+ A decorator marking the decorated function as typing and implementing
+ classmethod *attr* for the given Numba type in nopython mode.
+
+
+ Similar to ``overload_method``.
+
+
+ Here is an example implementing a classmethod on the Array type to call
+ ``np.arange()``::
+
+ @overload_classmethod(types.Array, "make")
+ def ov_make(cls, nitems):
+ def impl(cls, nitems):
+ return np.arange(nitems)
+ return impl
+
+ The above code will allow the following to work in jit-compiled code::
+
+ @njit
+ def foo(n):
+ return types.Array.make(n)
+ """
+ return _overload_method_common(types.TypeRef(typ), attr, **kwargs)
+
+
+def make_attribute_wrapper(typeclass, struct_attr, python_attr):
+ """
+ Make an automatic attribute wrapper exposing member named *struct_attr*
+ as a read-only attribute named *python_attr*.
+ The given *typeclass*'s model must be a StructModel subclass.
+ """
+ from numba.core.typing.templates import AttributeTemplate
+ from numba.core.datamodel import default_manager
+ from numba.core.datamodel.models import StructModel
+ from numba.core.imputils import impl_ret_borrowed
+ from numba.core import cgutils
+
+ if not isinstance(typeclass, type) or not issubclass(typeclass, types.Type):
+ raise TypeError("typeclass should be a Type subclass, got %s"
+ % (typeclass,))
+
+ def get_attr_fe_type(typ):
+ """
+ Get the Numba type of member *struct_attr* in *typ*.
+ """
+ model = default_manager.lookup(typ)
+ if not isinstance(model, StructModel):
+ raise TypeError("make_struct_attribute_wrapper() needs a type "
+ "with a StructModel, but got %s" % (model,))
+ return model.get_member_fe_type(struct_attr)
+
+ @infer_getattr
+ class StructAttribute(AttributeTemplate):
+ key = typeclass
+
+ def generic_resolve(self, typ, attr):
+ if attr == python_attr:
+ return get_attr_fe_type(typ)
+
+ @lower_getattr(typeclass, python_attr)
+ def struct_getattr_impl(context, builder, typ, val):
+ val = cgutils.create_struct_proxy(typ)(context, builder, value=val)
+ attrty = get_attr_fe_type(typ)
+ attrval = getattr(val, struct_attr)
+ return impl_ret_borrowed(context, builder, attrty, attrval)
+
+
+class _Intrinsic(ReduceMixin):
+ """
+ Dummy callable for intrinsic
+ """
+ _memo = weakref.WeakValueDictionary()
+ # hold refs to last N functions deserialized, retaining them in _memo
+ # regardless of whether there is another reference
+ _recent = collections.deque(maxlen=config.FUNCTION_CACHE_SIZE)
+
+ __uuid = None
+
+ def __init__(self, name, defn, prefer_literal=False, **kwargs):
+ self._ctor_kwargs = kwargs
+ self._name = name
+ self._defn = defn
+ self._prefer_literal = prefer_literal
+ functools.update_wrapper(self, defn)
+
+ @property
+ def _uuid(self):
+ """
+ An instance-specific UUID, to avoid multiple deserializations of
+ a given instance.
+
+ Note this is lazily-generated, for performance reasons.
+ """
+ u = self.__uuid
+ if u is None:
+ u = str(uuid.uuid1())
+ self._set_uuid(u)
+ return u
+
+ def _set_uuid(self, u):
+ assert self.__uuid is None
+ self.__uuid = u
+ self._memo[u] = self
+ self._recent.append(self)
+
+ def _register(self):
+ # _ctor_kwargs
+ from numba.core.typing.templates import (make_intrinsic_template,
+ infer_global)
+
+ template = make_intrinsic_template(self, self._defn, self._name,
+ prefer_literal=self._prefer_literal,
+ kwargs=self._ctor_kwargs)
+ infer(template)
+ infer_global(self, types.Function(template))
+
+ def __call__(self, *args, **kwargs):
+ """
+ This is only defined to pretend to be a callable from CPython.
+ """
+ msg = '{0} is not usable in pure-python'.format(self)
+ raise NotImplementedError(msg)
+
+ def __repr__(self):
+ return "".format(self._name)
+
+ def __deepcopy__(self, memo):
+ # NOTE: Intrinsic are immutable and we don't need to copy.
+ # This is triggered from deepcopy of statements.
+ return self
+
+ def _reduce_states(self):
+ """
+ NOTE: part of ReduceMixin protocol
+ """
+ return dict(uuid=self._uuid, name=self._name, defn=self._defn)
+
+ @classmethod
+ def _rebuild(cls, uuid, name, defn):
+ """
+ NOTE: part of ReduceMixin protocol
+ """
+ try:
+ return cls._memo[uuid]
+ except KeyError:
+ llc = cls(name=name, defn=defn)
+ llc._register()
+ llc._set_uuid(uuid)
+ return llc
+
+
+def intrinsic(*args, **kwargs):
+ """
+ A decorator marking the decorated function as typing and implementing
+ *func* in nopython mode using the llvmlite IRBuilder API. This is an escape
+ hatch for expert users to build custom LLVM IR that will be inlined to
+ the caller.
+
+ The first argument to *func* is the typing context. The rest of the
+ arguments corresponds to the type of arguments of the decorated function.
+ These arguments are also used as the formal argument of the decorated
+ function. If *func* has the signature ``foo(typing_context, arg0, arg1)``,
+ the decorated function will have the signature ``foo(arg0, arg1)``.
+
+ The return values of *func* should be a 2-tuple of expected type signature,
+ and a code-generation function that will passed to ``lower_builtin``.
+ For unsupported operation, return None.
+
+ Here is an example implementing a ``cast_int_to_byte_ptr`` that cast
+ any integer to a byte pointer::
+
+ @intrinsic
+ def cast_int_to_byte_ptr(typingctx, src):
+ # check for accepted types
+ if isinstance(src, types.Integer):
+ # create the expected type signature
+ result_type = types.CPointer(types.uint8)
+ sig = result_type(types.uintp)
+ # defines the custom code generation
+ def codegen(context, builder, signature, args):
+ # llvm IRBuilder code here
+ [src] = args
+ rtype = signature.return_type
+ llrtype = context.get_value_type(rtype)
+ return builder.inttoptr(src, llrtype)
+ return sig, codegen
+ """
+ # Make inner function for the actual work
+ def _intrinsic(func):
+ name = getattr(func, '__name__', str(func))
+ llc = _Intrinsic(name, func, **kwargs)
+ llc._register()
+ return llc
+
+ if not kwargs:
+ # No option is given
+ return _intrinsic(*args)
+ else:
+ # options are given, create a new callable to recv the
+ # definition function
+ def wrapper(func):
+ return _intrinsic(func)
+ return wrapper
+
+
+def get_cython_function_address(module_name, function_name):
+ """
+ Get the address of a Cython function.
+
+ Args
+ ----
+ module_name:
+ Name of the Cython module
+ function_name:
+ Name of the Cython function
+
+ Returns
+ -------
+ A Python int containing the address of the function
+
+ """
+ return _import_cython_function(module_name, function_name)
+
+
+def include_path():
+ """Returns the C include directory path.
+ """
+ include_dir = os.path.dirname(os.path.dirname(numba.__file__))
+ path = os.path.abspath(include_dir)
+ return path
+
+
+def sentry_literal_args(pysig, literal_args, args, kwargs):
+ """Ensures that the given argument types (in *args* and *kwargs*) are
+ literally typed for a function with the python signature *pysig* and the
+ list of literal argument names in *literal_args*.
+
+ Alternatively, this is the same as::
+
+ SentryLiteralArgs(literal_args).for_pysig(pysig).bind(*args, **kwargs)
+ """
+ boundargs = pysig.bind(*args, **kwargs)
+
+ # Find literal argument positions and whether it is satisfied.
+ request_pos = set()
+ missing = False
+ for i, (k, v) in enumerate(boundargs.arguments.items()):
+ if k in literal_args:
+ request_pos.add(i)
+ if not isinstance(v, types.Literal):
+ missing = True
+ if missing:
+ # Yes, there are missing required literal arguments
+ e = errors.ForceLiteralArg(request_pos)
+
+ # A helper function to fold arguments
+ def folded(args, kwargs):
+ out = pysig.bind(*args, **kwargs).arguments.values()
+ return tuple(out)
+
+ raise e.bind_fold_arguments(folded)
+
+
+class SentryLiteralArgs(collections.namedtuple(
+ '_SentryLiteralArgs', ['literal_args'])):
+ """
+ Parameters
+ ----------
+ literal_args : Sequence[str]
+ A sequence of names for literal arguments
+
+ Examples
+ --------
+
+ The following line:
+
+ >>> SentryLiteralArgs(literal_args).for_pysig(pysig).bind(*args, **kwargs)
+
+ is equivalent to:
+
+ >>> sentry_literal_args(pysig, literal_args, args, kwargs)
+ """
+ def for_function(self, func):
+ """Bind the sentry to the signature of *func*.
+
+ Parameters
+ ----------
+ func : Function
+ A python function.
+
+ Returns
+ -------
+ obj : BoundLiteralArgs
+ """
+ return self.for_pysig(utils.pysignature(func))
+
+ def for_pysig(self, pysig):
+ """Bind the sentry to the given signature *pysig*.
+
+ Parameters
+ ----------
+ pysig : inspect.Signature
+
+
+ Returns
+ -------
+ obj : BoundLiteralArgs
+ """
+ return BoundLiteralArgs(
+ pysig=pysig,
+ literal_args=self.literal_args,
+ )
+
+
+class BoundLiteralArgs(collections.namedtuple(
+ 'BoundLiteralArgs', ['pysig', 'literal_args'])):
+ """
+ This class is usually created by SentryLiteralArgs.
+ """
+ def bind(self, *args, **kwargs):
+ """Bind to argument types.
+ """
+ return sentry_literal_args(
+ self.pysig,
+ self.literal_args,
+ args,
+ kwargs,
+ )
+
+
+def is_jitted(function):
+ """Returns True if a function is wrapped by one of the Numba @jit
+ decorators, for example: numba.jit, numba.njit
+
+ The purpose of this function is to provide a means to check if a function is
+ already JIT decorated.
+ """
+
+ # don't want to export this so import locally
+ from numba.core.dispatcher import Dispatcher
+ return isinstance(function, Dispatcher)
diff --git a/venv/lib/python3.10/site-packages/numba/core/externals.py b/venv/lib/python3.10/site-packages/numba/core/externals.py
new file mode 100644
index 0000000000000000000000000000000000000000..e181b5f43d9d8dda06a84ba93a176058cc5b1543
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/externals.py
@@ -0,0 +1,155 @@
+"""
+Register external C functions necessary for Numba code generation.
+"""
+
+import sys
+
+from llvmlite import ir
+import llvmlite.binding as ll
+
+from numba.core import utils, intrinsics
+from numba import _helperlib
+
+
+def _add_missing_symbol(symbol, addr):
+ """Add missing symbol into LLVM internal symtab
+ """
+ if not ll.address_of_symbol(symbol):
+ ll.add_symbol(symbol, addr)
+
+
+def _get_msvcrt_symbol(symbol):
+ """
+ Under Windows, look up a symbol inside the C runtime
+ and return the raw pointer value as an integer.
+ """
+ from ctypes import cdll, cast, c_void_p
+ f = getattr(cdll.msvcrt, symbol)
+ return cast(f, c_void_p).value
+
+
+def compile_multi3(context):
+ """
+ Compile the multi3() helper function used by LLVM
+ for 128-bit multiplication on 32-bit platforms.
+ """
+ codegen = context.codegen()
+ library = codegen.create_library("multi3")
+
+ ir_mod = library.create_ir_module("multi3")
+
+ i64 = ir.IntType(64)
+ i128 = ir.IntType(128)
+ lower_mask = ir.Constant(i64, 0xffffffff)
+ _32 = ir.Constant(i64, 32)
+ _64 = ir.Constant(i128, 64)
+
+ fn_type = ir.FunctionType(i128, [i128, i128])
+ fn = ir.Function(ir_mod, fn_type, name="multi3")
+
+ a, b = fn.args
+ bb = fn.append_basic_block()
+ builder = ir.IRBuilder(bb)
+
+ # This implementation mimics compiler-rt's.
+ al = builder.trunc(a, i64)
+ bl = builder.trunc(b, i64)
+ ah = builder.trunc(builder.ashr(a, _64), i64)
+ bh = builder.trunc(builder.ashr(b, _64), i64)
+
+ # Compute {rh, rl} = al * bl (unsigned 64-bit multiplication)
+ # rl = (al & 0xffffffff) * (bl & 0xffffffff)
+ rl = builder.mul(builder.and_(al, lower_mask), builder.and_(bl, lower_mask))
+ # t = rl >> 32
+ t = builder.lshr(rl, _32)
+ # rl &= 0xffffffff
+ rl = builder.and_(rl, lower_mask)
+ # t += (al >> 32) * (bl & 0xffffffff)
+ t = builder.add(t, builder.mul(builder.lshr(al, _32),
+ builder.and_(bl, lower_mask)))
+ # rl += t << 32
+ rl = builder.add(rl, builder.shl(t, _32))
+ # rh = t >> 32
+ rh = builder.lshr(t, _32)
+ # t = rl >> 32
+ t = builder.lshr(rl, _32)
+ # rl &= 0xffffffff
+ rl = builder.and_(rl, lower_mask)
+ # t += (bl >> 32) * (al & 0xffffffff)
+ t = builder.add(t, builder.mul(builder.lshr(bl, _32),
+ builder.and_(al, lower_mask)))
+ # rl += t << 32
+ rl = builder.add(rl, builder.shl(t, _32))
+ # rh += t >> 32
+ rh = builder.add(rh, builder.lshr(t, _32))
+ # rh += (al >> 32) * (bl >> 32)
+ rh = builder.add(rh, builder.mul(builder.lshr(al, _32),
+ builder.lshr(bl, _32)))
+
+ # rh += (bh * al) + (bl * ah)
+ rh = builder.add(rh, builder.mul(bh, al))
+ rh = builder.add(rh, builder.mul(bl, ah))
+
+ # r = rl + (rh << 64)
+ r = builder.zext(rl, i128)
+ r = builder.add(r, builder.shl(builder.zext(rh, i128), _64))
+ builder.ret(r)
+
+ library.add_ir_module(ir_mod)
+ library.finalize()
+
+ return library
+
+
+class _Installer(object):
+
+ _installed = False
+
+ def install(self, context):
+ """
+ Install the functions into LLVM. This only needs to be done once,
+ as the mappings are persistent during the process lifetime.
+ """
+ if not self._installed:
+ self._do_install(context)
+ self._installed = True
+
+
+class _ExternalMathFunctions(_Installer):
+ """
+ Map the math functions from the C runtime library into the LLVM
+ execution environment.
+ """
+
+ def _do_install(self, context):
+ is32bit = utils.MACHINE_BITS == 32
+ c_helpers = _helperlib.c_helpers
+
+ if sys.platform.startswith('win32') and is32bit:
+ # For Windows XP _ftol2 is not defined, we will just use
+ # _ftol as a replacement.
+ # On Windows 7, this is not necessary but will work anyway.
+ ftol = _get_msvcrt_symbol("_ftol")
+ _add_missing_symbol("_ftol2", ftol)
+
+ elif sys.platform.startswith('linux') and is32bit:
+ _add_missing_symbol("__fixunsdfdi", c_helpers["fptoui"])
+ _add_missing_symbol("__fixunssfdi", c_helpers["fptouif"])
+
+ if is32bit:
+ # Make the library immortal
+ self._multi3_lib = compile_multi3(context)
+ ptr = self._multi3_lib.get_pointer_to_function("multi3")
+ assert ptr
+ _add_missing_symbol("__multi3", ptr)
+
+ # List available C-math
+ for fname in intrinsics.INTR_MATH:
+ # Force binding from CPython's C runtime library.
+ # (under Windows, different versions of the C runtime can
+ # be loaded at the same time, for example msvcrt100 by
+ # CPython and msvcrt120 by LLVM)
+ ll.add_symbol(fname, c_helpers[fname])
+
+
+c_math_functions = _ExternalMathFunctions()
diff --git a/venv/lib/python3.10/site-packages/numba/core/fastmathpass.py b/venv/lib/python3.10/site-packages/numba/core/fastmathpass.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6dd1b89c20cb78cd9b819663aa21ce270ce4bbe
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/fastmathpass.py
@@ -0,0 +1,44 @@
+from llvmlite import ir
+from llvmlite.ir.transforms import Visitor, CallVisitor
+
+
+class FastFloatBinOpVisitor(Visitor):
+ """
+ A pass to add fastmath flag to float-binop instruction if they don't have
+ any flags.
+ """
+ float_binops = frozenset(['fadd', 'fsub', 'fmul', 'fdiv', 'frem', 'fcmp'])
+
+ def __init__(self, flags):
+ self.flags = flags
+
+ def visit_Instruction(self, instr):
+ if instr.opname in self.float_binops:
+ if not instr.flags:
+ for flag in self.flags:
+ instr.flags.append(flag)
+
+
+class FastFloatCallVisitor(CallVisitor):
+ """
+ A pass to change all float function calls to use fastmath.
+ """
+
+ def __init__(self, flags):
+ self.flags = flags
+
+ def visit_Call(self, instr):
+ # Add to any call that has float/double return type
+ if instr.type in (ir.FloatType(), ir.DoubleType()):
+ for flag in self.flags:
+ instr.fastmath.add(flag)
+
+
+def rewrite_module(mod, options):
+ """
+ Rewrite the given LLVM module to use fastmath everywhere.
+ """
+ flags = options.flags
+ FastFloatBinOpVisitor(flags).visit(mod)
+ FastFloatCallVisitor(flags).visit(mod)
+
diff --git a/venv/lib/python3.10/site-packages/numba/core/funcdesc.py b/venv/lib/python3.10/site-packages/numba/core/funcdesc.py
new file mode 100644
index 0000000000000000000000000000000000000000..0508a3aaeed8d5746d5f76f731620d6056a190b5
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/funcdesc.py
@@ -0,0 +1,230 @@
+"""
+Function descriptors.
+"""
+
+from collections import defaultdict
+import importlib
+
+from numba.core import types, itanium_mangler
+from numba.core.utils import _dynamic_modname, _dynamic_module
+
+
+def default_mangler(name, argtypes, *, abi_tags=(), uid=None):
+ return itanium_mangler.mangle(name, argtypes, abi_tags=abi_tags, uid=uid)
+
+
+def qualifying_prefix(modname, qualname):
+ """
+ Returns a new string that is used for the first half of the mangled name.
+ """
+ # XXX choose a different convention for object mode
+ return '{}.{}'.format(modname, qualname) if modname else qualname
+
+
+class FunctionDescriptor(object):
+ """
+ Base class for function descriptors: an object used to carry
+ useful metadata about a natively callable function.
+
+ Note that while `FunctionIdentity` denotes a Python function
+ which is being concretely compiled by Numba, `FunctionDescriptor`
+ may be more "abstract".
+ """
+ __slots__ = ('native', 'modname', 'qualname', 'doc', 'typemap',
+ 'calltypes', 'args', 'kws', 'restype', 'argtypes',
+ 'mangled_name', 'unique_name', 'env_name', 'global_dict',
+ 'inline', 'noalias', 'abi_tags', 'uid')
+
+ def __init__(self, native, modname, qualname, unique_name, doc,
+ typemap, restype, calltypes, args, kws, mangler=None,
+ argtypes=None, inline=False, noalias=False, env_name=None,
+ global_dict=None, abi_tags=(), uid=None):
+ self.native = native
+ self.modname = modname
+ self.global_dict = global_dict
+ self.qualname = qualname
+ self.unique_name = unique_name
+ self.doc = doc
+ # XXX typemap and calltypes should be on the compile result,
+ # not the FunctionDescriptor
+ self.typemap = typemap
+ self.calltypes = calltypes
+ self.args = args
+ self.kws = kws
+ self.restype = restype
+ # Argument types
+ if argtypes is not None:
+ assert isinstance(argtypes, tuple), argtypes
+ self.argtypes = argtypes
+ else:
+ # Get argument types from the type inference result
+ # (note the "arg.FOO" convention as used in typeinfer
+ self.argtypes = tuple(self.typemap['arg.' + a] for a in args)
+ mangler = default_mangler if mangler is None else mangler
+ # The mangled name *must* be unique, else the wrong function can
+ # be chosen at link time.
+ qualprefix = qualifying_prefix(self.modname, self.qualname)
+ self.uid = uid
+ self.mangled_name = mangler(
+ qualprefix, self.argtypes, abi_tags=abi_tags, uid=uid,
+ )
+ if env_name is None:
+ env_name = mangler(".NumbaEnv.{}".format(qualprefix),
+ self.argtypes, abi_tags=abi_tags, uid=uid)
+ self.env_name = env_name
+ self.inline = inline
+ self.noalias = noalias
+ self.abi_tags = abi_tags
+
+ def lookup_globals(self):
+ """
+ Return the global dictionary of the function.
+ It may not match the Module's globals if the function is created
+ dynamically (i.e. exec)
+ """
+ return self.global_dict or self.lookup_module().__dict__
+
+ def lookup_module(self):
+ """
+ Return the module in which this function is supposed to exist.
+ This may be a dummy module if the function was dynamically
+ generated or the module can't be found.
+ """
+ if self.modname == _dynamic_modname:
+ return _dynamic_module
+ else:
+ try:
+ # ensure module exist
+ return importlib.import_module(self.modname)
+ except ImportError:
+ return _dynamic_module
+
+ def lookup_function(self):
+ """
+ Return the original function object described by this object.
+ """
+ return getattr(self.lookup_module(), self.qualname)
+
+ @property
+ def llvm_func_name(self):
+ """
+ The LLVM-registered name for the raw function.
+ """
+ return self.mangled_name
+
+ # XXX refactor this
+
+ @property
+ def llvm_cpython_wrapper_name(self):
+ """
+ The LLVM-registered name for a CPython-compatible wrapper of the
+ raw function (i.e. a PyCFunctionWithKeywords).
+ """
+ return itanium_mangler.prepend_namespace(self.mangled_name,
+ ns='cpython')
+
+ @property
+ def llvm_cfunc_wrapper_name(self):
+ """
+ The LLVM-registered name for a C-compatible wrapper of the
+ raw function.
+ """
+ return 'cfunc.' + self.mangled_name
+
+ def __repr__(self):
+ return "" % (self.unique_name)
+
+ @classmethod
+ def _get_function_info(cls, func_ir):
+ """
+ Returns
+ -------
+ qualname, unique_name, modname, doc, args, kws, globals
+
+ ``unique_name`` must be a unique name.
+ """
+ func = func_ir.func_id.func
+ qualname = func_ir.func_id.func_qualname
+ # XXX to func_id
+ modname = func.__module__
+ doc = func.__doc__ or ''
+ args = tuple(func_ir.arg_names)
+ kws = () # TODO
+ global_dict = None
+
+ if modname is None:
+ # Dynamically generated function.
+ modname = _dynamic_modname
+ # Retain a reference to the dictionary of the function.
+ # This disables caching, serialization and pickling.
+ global_dict = func_ir.func_id.func.__globals__
+
+ unique_name = func_ir.func_id.unique_name
+
+ return qualname, unique_name, modname, doc, args, kws, global_dict
+
+ @classmethod
+ def _from_python_function(cls, func_ir, typemap, restype,
+ calltypes, native, mangler=None,
+ inline=False, noalias=False, abi_tags=()):
+ (qualname, unique_name, modname, doc, args, kws, global_dict,
+ ) = cls._get_function_info(func_ir)
+
+ self = cls(native, modname, qualname, unique_name, doc,
+ typemap, restype, calltypes,
+ args, kws, mangler=mangler, inline=inline, noalias=noalias,
+ global_dict=global_dict, abi_tags=abi_tags,
+ uid=func_ir.func_id.unique_id)
+ return self
+
+
+class PythonFunctionDescriptor(FunctionDescriptor):
+ """
+ A FunctionDescriptor subclass for Numba-compiled functions.
+ """
+ __slots__ = ()
+
+ @classmethod
+ def from_specialized_function(cls, func_ir, typemap, restype, calltypes,
+ mangler, inline, noalias, abi_tags):
+ """
+ Build a FunctionDescriptor for a given specialization of a Python
+ function (in nopython mode).
+ """
+ return cls._from_python_function(func_ir, typemap, restype, calltypes,
+ native=True, mangler=mangler,
+ inline=inline, noalias=noalias,
+ abi_tags=abi_tags)
+
+ @classmethod
+ def from_object_mode_function(cls, func_ir):
+ """
+ Build a FunctionDescriptor for an object mode variant of a Python
+ function.
+ """
+ typemap = defaultdict(lambda: types.pyobject)
+ calltypes = typemap.copy()
+ restype = types.pyobject
+ return cls._from_python_function(func_ir, typemap, restype, calltypes,
+ native=False)
+
+
+class ExternalFunctionDescriptor(FunctionDescriptor):
+ """
+ A FunctionDescriptor subclass for opaque external functions
+ (e.g. raw C functions).
+ """
+ __slots__ = ()
+
+ def __init__(self, name, restype, argtypes):
+ args = ["arg%d" % i for i in range(len(argtypes))]
+
+ def mangler(a, x, abi_tags, uid=None):
+ return a
+ super(ExternalFunctionDescriptor, self
+ ).__init__(native=True, modname=None, qualname=name,
+ unique_name=name, doc='', typemap=None,
+ restype=restype, calltypes=None, args=args,
+ kws=None,
+ mangler=mangler,
+ argtypes=argtypes)
diff --git a/venv/lib/python3.10/site-packages/numba/core/generators.py b/venv/lib/python3.10/site-packages/numba/core/generators.py
new file mode 100644
index 0000000000000000000000000000000000000000..88456bdabb0639d10d993156d24ebf30c6eb9b8c
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/generators.py
@@ -0,0 +1,360 @@
+"""
+Support for lowering generators.
+"""
+
+import llvmlite.ir
+from llvmlite.ir import Constant, IRBuilder
+
+from numba.core import types, config, cgutils
+from numba.core.funcdesc import FunctionDescriptor
+
+
+class GeneratorDescriptor(FunctionDescriptor):
+ """
+ The descriptor for a generator's next function.
+ """
+ __slots__ = ()
+
+ @classmethod
+ def from_generator_fndesc(cls, func_ir, fndesc, gentype, mangler):
+ """
+ Build a GeneratorDescriptor for the generator returned by the
+ function described by *fndesc*, with type *gentype*.
+
+ The generator inherits the env_name from the *fndesc*.
+ All emitted functions for the generator shares the same Env.
+ """
+ assert isinstance(gentype, types.Generator)
+ restype = gentype.yield_type
+ args = ['gen']
+ argtypes = (gentype,)
+ qualname = fndesc.qualname + '.next'
+ unique_name = fndesc.unique_name + '.next'
+ self = cls(fndesc.native, fndesc.modname, qualname, unique_name,
+ fndesc.doc, fndesc.typemap, restype, fndesc.calltypes,
+ args, fndesc.kws, argtypes=argtypes, mangler=mangler,
+ inline=False, env_name=fndesc.env_name)
+ return self
+
+ @property
+ def llvm_finalizer_name(self):
+ """
+ The LLVM name of the generator's finalizer function
+ (if .has_finalizer is true).
+ """
+ return 'finalize_' + self.mangled_name
+
+
+class BaseGeneratorLower(object):
+ """
+ Base support class for lowering generators.
+ """
+
+ def __init__(self, lower):
+ self.context = lower.context
+ self.fndesc = lower.fndesc
+ self.library = lower.library
+ self.func_ir = lower.func_ir
+ self.lower = lower
+
+ self.geninfo = lower.generator_info
+ self.gentype = self.get_generator_type()
+ self.gendesc = GeneratorDescriptor.from_generator_fndesc(
+ lower.func_ir, self.fndesc, self.gentype, self.context.mangler)
+ # Helps packing non-omitted arguments into a structure
+ self.arg_packer = self.context.get_data_packer(self.fndesc.argtypes)
+
+ self.resume_blocks = {}
+
+ @property
+ def call_conv(self):
+ return self.lower.call_conv
+
+ def get_args_ptr(self, builder, genptr):
+ return cgutils.gep_inbounds(builder, genptr, 0, 1)
+
+ def get_resume_index_ptr(self, builder, genptr):
+ return cgutils.gep_inbounds(builder, genptr, 0, 0,
+ name='gen.resume_index')
+
+ def get_state_ptr(self, builder, genptr):
+ return cgutils.gep_inbounds(builder, genptr, 0, 2,
+ name='gen.state')
+
+ def lower_init_func(self, lower):
+ """
+ Lower the generator's initialization function (which will fill up
+ the passed-by-reference generator structure).
+ """
+ lower.setup_function(self.fndesc)
+
+ builder = lower.builder
+
+ # Insert the generator into the target context in order to allow
+ # calling from other Numba-compiled functions.
+ lower.context.insert_generator(self.gentype, self.gendesc,
+ [self.library])
+
+ # Init argument values
+ lower.extract_function_arguments()
+
+ lower.pre_lower()
+
+ # Initialize the return structure (i.e. the generator structure).
+ retty = self.context.get_return_type(self.gentype)
+ # Structure index #0: the initial resume index (0 == start of generator)
+ resume_index = self.context.get_constant(types.int32, 0)
+ # Structure index #1: the function arguments
+ argsty = retty.elements[1]
+ statesty = retty.elements[2]
+
+ lower.debug_print("# low_init_func incref")
+ # Incref all NRT arguments before storing into generator states
+ if self.context.enable_nrt:
+ for argty, argval in zip(self.fndesc.argtypes, lower.fnargs):
+ self.context.nrt.incref(builder, argty, argval)
+
+ # Filter out omitted arguments
+ argsval = self.arg_packer.as_data(builder, lower.fnargs)
+
+ # Zero initialize states
+ statesval = Constant(statesty, None)
+ gen_struct = cgutils.make_anonymous_struct(builder,
+ [resume_index, argsval,
+ statesval],
+ retty)
+
+ retval = self.box_generator_struct(lower, gen_struct)
+
+ lower.debug_print("# low_init_func before return")
+ self.call_conv.return_value(builder, retval)
+ lower.post_lower()
+
+ def lower_next_func(self, lower):
+ """
+ Lower the generator's next() function (which takes the
+ passed-by-reference generator structure and returns the next
+ yielded value).
+ """
+ lower.setup_function(self.gendesc)
+ lower.debug_print("# lower_next_func: {0}".format(self.gendesc.unique_name))
+ assert self.gendesc.argtypes[0] == self.gentype
+ builder = lower.builder
+ function = lower.function
+
+ # Extract argument values and other information from generator struct
+ genptr, = self.call_conv.get_arguments(function)
+ self.arg_packer.load_into(builder,
+ self.get_args_ptr(builder, genptr),
+ lower.fnargs)
+
+ self.resume_index_ptr = self.get_resume_index_ptr(builder, genptr)
+ self.gen_state_ptr = self.get_state_ptr(builder, genptr)
+
+ prologue = function.append_basic_block("generator_prologue")
+
+ # Lower the generator's Python code
+ entry_block_tail = lower.lower_function_body()
+
+ # Add block for StopIteration on entry
+ stop_block = function.append_basic_block("stop_iteration")
+ builder.position_at_end(stop_block)
+ self.call_conv.return_stop_iteration(builder)
+
+ # Add prologue switch to resume blocks
+ builder.position_at_end(prologue)
+ # First Python block is also the resume point on first next() call
+ first_block = self.resume_blocks[0] = lower.blkmap[lower.firstblk]
+
+ # Create front switch to resume points
+ switch = builder.switch(builder.load(self.resume_index_ptr),
+ stop_block)
+ for index, block in self.resume_blocks.items():
+ switch.add_case(index, block)
+
+ # Close tail of entry block
+ builder.position_at_end(entry_block_tail)
+ builder.branch(prologue)
+
+ def lower_finalize_func(self, lower):
+ """
+ Lower the generator's finalizer.
+ """
+ fnty = llvmlite.ir.FunctionType(llvmlite.ir.VoidType(),
+ [self.context.get_value_type(self.gentype)])
+ function = cgutils.get_or_insert_function(
+ lower.module, fnty, self.gendesc.llvm_finalizer_name)
+ entry_block = function.append_basic_block('entry')
+ builder = IRBuilder(entry_block)
+
+ genptrty = self.context.get_value_type(self.gentype)
+ genptr = builder.bitcast(function.args[0], genptrty)
+ self.lower_finalize_func_body(builder, genptr)
+
+ def return_from_generator(self, lower):
+ """
+ Emit a StopIteration at generator end and mark the generator exhausted.
+ """
+ indexval = Constant(self.resume_index_ptr.type.pointee, -1)
+ lower.builder.store(indexval, self.resume_index_ptr)
+ self.call_conv.return_stop_iteration(lower.builder)
+
+ def create_resumption_block(self, lower, index):
+ block_name = "generator_resume%d" % (index,)
+ block = lower.function.append_basic_block(block_name)
+ lower.builder.position_at_end(block)
+ self.resume_blocks[index] = block
+
+ def debug_print(self, builder, msg):
+ if config.DEBUG_JIT:
+ self.context.debug_print(builder, "DEBUGJIT: {0}".format(msg))
+
+class GeneratorLower(BaseGeneratorLower):
+ """
+ Support class for lowering nopython generators.
+ """
+
+ def get_generator_type(self):
+ return self.fndesc.restype
+
+ def box_generator_struct(self, lower, gen_struct):
+ return gen_struct
+
+ def lower_finalize_func_body(self, builder, genptr):
+ """
+ Lower the body of the generator's finalizer: decref all live
+ state variables.
+ """
+ self.debug_print(builder, "# generator: finalize")
+ if self.context.enable_nrt:
+
+ # Always dereference all arguments
+ # self.debug_print(builder, "# generator: clear args")
+ args_ptr = self.get_args_ptr(builder, genptr)
+ for ty, val in self.arg_packer.load(builder, args_ptr):
+ self.context.nrt.decref(builder, ty, val)
+
+ self.debug_print(builder, "# generator: finalize end")
+ builder.ret_void()
+
+class PyGeneratorLower(BaseGeneratorLower):
+ """
+ Support class for lowering object mode generators.
+ """
+
+ def get_generator_type(self):
+ """
+ Compute the actual generator type (the generator function's return
+ type is simply "pyobject").
+ """
+ return types.Generator(
+ gen_func=self.func_ir.func_id.func,
+ yield_type=types.pyobject,
+ arg_types=(types.pyobject,) * self.func_ir.arg_count,
+ state_types=(types.pyobject,) * len(self.geninfo.state_vars),
+ has_finalizer=True,
+ )
+
+ def box_generator_struct(self, lower, gen_struct):
+ """
+ Box the raw *gen_struct* as a Python object.
+ """
+ gen_ptr = cgutils.alloca_once_value(lower.builder, gen_struct)
+ return lower.pyapi.from_native_generator(gen_ptr, self.gentype, lower.envarg)
+
+ def init_generator_state(self, lower):
+ """
+ NULL-initialize all generator state variables, to avoid spurious
+ decref's on cleanup.
+ """
+ lower.builder.store(Constant(self.gen_state_ptr.type.pointee, None),
+ self.gen_state_ptr)
+
+ def lower_finalize_func_body(self, builder, genptr):
+ """
+ Lower the body of the generator's finalizer: decref all live
+ state variables.
+ """
+ pyapi = self.context.get_python_api(builder)
+ resume_index_ptr = self.get_resume_index_ptr(builder, genptr)
+ resume_index = builder.load(resume_index_ptr)
+ # If resume_index is 0, next() was never called
+ # If resume_index is -1, generator terminated cleanly
+ # (note function arguments are saved in state variables,
+ # so they don't need a separate cleanup step)
+ need_cleanup = builder.icmp_signed(
+ '>', resume_index, Constant(resume_index.type, 0))
+
+ with cgutils.if_unlikely(builder, need_cleanup):
+ # Decref all live vars (some may be NULL)
+ gen_state_ptr = self.get_state_ptr(builder, genptr)
+ for state_index in range(len(self.gentype.state_types)):
+ state_slot = cgutils.gep_inbounds(builder, gen_state_ptr,
+ 0, state_index)
+ ty = self.gentype.state_types[state_index]
+ val = self.context.unpack_value(builder, ty, state_slot)
+ pyapi.decref(val)
+
+ builder.ret_void()
+
+
+class LowerYield(object):
+ """
+ Support class for lowering a particular yield point.
+ """
+
+ def __init__(self, lower, yield_point, live_vars):
+ self.lower = lower
+ self.context = lower.context
+ self.builder = lower.builder
+ self.genlower = lower.genlower
+ self.gentype = self.genlower.gentype
+
+ self.gen_state_ptr = self.genlower.gen_state_ptr
+ self.resume_index_ptr = self.genlower.resume_index_ptr
+ self.yp = yield_point
+ self.inst = self.yp.inst
+ self.live_vars = live_vars
+ self.live_var_indices = [lower.generator_info.state_vars.index(v)
+ for v in live_vars]
+
+ def lower_yield_suspend(self):
+ self.lower.debug_print("# generator suspend")
+ # Save live vars in state
+ for state_index, name in zip(self.live_var_indices, self.live_vars):
+ state_slot = cgutils.gep_inbounds(self.builder, self.gen_state_ptr,
+ 0, state_index)
+ ty = self.gentype.state_types[state_index]
+ # The yield might be in a loop, in which case the state might
+ # contain a predicate var that branches back to the loop head, in
+ # this case the var is live but in sequential lowering won't have
+ # been alloca'd yet, so do this here.
+ fetype = self.lower.typeof(name)
+ self.lower._alloca_var(name, fetype)
+ val = self.lower.loadvar(name)
+ # IncRef newly stored value
+ if self.context.enable_nrt:
+ self.context.nrt.incref(self.builder, ty, val)
+
+ self.context.pack_value(self.builder, ty, val, state_slot)
+ # Save resume index
+ indexval = Constant(self.resume_index_ptr.type.pointee,
+ self.inst.index)
+ self.builder.store(indexval, self.resume_index_ptr)
+ self.lower.debug_print("# generator suspend end")
+
+ def lower_yield_resume(self):
+ # Emit resumption point
+ self.genlower.create_resumption_block(self.lower, self.inst.index)
+ self.lower.debug_print("# generator resume")
+ # Reload live vars from state
+ for state_index, name in zip(self.live_var_indices, self.live_vars):
+ state_slot = cgutils.gep_inbounds(self.builder, self.gen_state_ptr,
+ 0, state_index)
+ ty = self.gentype.state_types[state_index]
+ val = self.context.unpack_value(self.builder, ty, state_slot)
+ self.lower.storevar(val, name)
+ # Previous storevar is making an extra incref
+ if self.context.enable_nrt:
+ self.context.nrt.decref(self.builder, ty, val)
+ self.lower.debug_print("# generator resume end")
diff --git a/venv/lib/python3.10/site-packages/numba/core/imputils.py b/venv/lib/python3.10/site-packages/numba/core/imputils.py
new file mode 100644
index 0000000000000000000000000000000000000000..06c35abb9cf99389b6015755fb9aec7048c8387f
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/imputils.py
@@ -0,0 +1,469 @@
+"""
+Utilities to simplify the boilerplate for native lowering.
+"""
+
+
+import collections
+import contextlib
+import inspect
+import functools
+from enum import Enum
+
+from numba.core import typing, types, utils, cgutils
+from numba.core.typing.templates import BaseRegistryLoader
+
+
+class Registry(object):
+ """
+ A registry of function and attribute implementations.
+ """
+ def __init__(self, name='unspecified'):
+ self.name = name
+ self.functions = []
+ self.getattrs = []
+ self.setattrs = []
+ self.casts = []
+ self.constants = []
+
+ def lower(self, func, *argtys):
+ """
+ Decorate an implementation of *func* for the given argument types.
+ *func* may be an actual global function object, or any
+ pseudo-function supported by Numba, such as "getitem".
+
+ The decorated implementation has the signature
+ (context, builder, sig, args).
+ """
+ def decorate(impl):
+ self.functions.append((impl, func, argtys))
+ return impl
+ return decorate
+
+ def _decorate_attr(self, impl, ty, attr, impl_list, decorator):
+ real_impl = decorator(impl, ty, attr)
+ impl_list.append((real_impl, attr, real_impl.signature))
+ return impl
+
+ def lower_getattr(self, ty, attr):
+ """
+ Decorate an implementation of __getattr__ for type *ty* and
+ the attribute *attr*.
+
+ The decorated implementation will have the signature
+ (context, builder, typ, val).
+ """
+ def decorate(impl):
+ return self._decorate_attr(impl, ty, attr, self.getattrs,
+ _decorate_getattr)
+ return decorate
+
+ def lower_getattr_generic(self, ty):
+ """
+ Decorate the fallback implementation of __getattr__ for type *ty*.
+
+ The decorated implementation will have the signature
+ (context, builder, typ, val, attr). The implementation is
+ called for attributes which haven't been explicitly registered
+ with lower_getattr().
+ """
+ return self.lower_getattr(ty, None)
+
+ def lower_setattr(self, ty, attr):
+ """
+ Decorate an implementation of __setattr__ for type *ty* and
+ the attribute *attr*.
+
+ The decorated implementation will have the signature
+ (context, builder, sig, args).
+ """
+ def decorate(impl):
+ return self._decorate_attr(impl, ty, attr, self.setattrs,
+ _decorate_setattr)
+ return decorate
+
+ def lower_setattr_generic(self, ty):
+ """
+ Decorate the fallback implementation of __setattr__ for type *ty*.
+
+ The decorated implementation will have the signature
+ (context, builder, sig, args, attr). The implementation is
+ called for attributes which haven't been explicitly registered
+ with lower_setattr().
+ """
+ return self.lower_setattr(ty, None)
+
+ def lower_cast(self, fromty, toty):
+ """
+ Decorate the implementation of implicit conversion between
+ *fromty* and *toty*.
+
+ The decorated implementation will have the signature
+ (context, builder, fromty, toty, val).
+ """
+ def decorate(impl):
+ self.casts.append((impl, (fromty, toty)))
+ return impl
+ return decorate
+
+ def lower_constant(self, ty):
+ """
+ Decorate the implementation for creating a constant of type *ty*.
+
+ The decorated implementation will have the signature
+ (context, builder, ty, pyval).
+ """
+ def decorate(impl):
+ self.constants.append((impl, (ty,)))
+ return impl
+ return decorate
+
+ def __repr__(self):
+ return f"Lowering Registry<{self.name}>"
+
+
+class RegistryLoader(BaseRegistryLoader):
+ """
+ An incremental loader for a target registry.
+ """
+ registry_items = ('functions', 'getattrs', 'setattrs', 'casts', 'constants')
+
+
+# Global registry for implementations of builtin operations
+# (functions, attributes, type casts)
+builtin_registry = Registry('builtin_registry')
+
+lower_builtin = builtin_registry.lower
+lower_getattr = builtin_registry.lower_getattr
+lower_getattr_generic = builtin_registry.lower_getattr_generic
+lower_setattr = builtin_registry.lower_setattr
+lower_setattr_generic = builtin_registry.lower_setattr_generic
+lower_cast = builtin_registry.lower_cast
+lower_constant = builtin_registry.lower_constant
+
+
+def _decorate_getattr(impl, ty, attr):
+ real_impl = impl
+
+ if attr is not None:
+ def res(context, builder, typ, value, attr):
+ return real_impl(context, builder, typ, value)
+ else:
+ def res(context, builder, typ, value, attr):
+ return real_impl(context, builder, typ, value, attr)
+
+ res.signature = (ty,)
+ res.attr = attr
+ return res
+
+def _decorate_setattr(impl, ty, attr):
+ real_impl = impl
+
+ if attr is not None:
+ def res(context, builder, sig, args, attr):
+ return real_impl(context, builder, sig, args)
+ else:
+ def res(context, builder, sig, args, attr):
+ return real_impl(context, builder, sig, args, attr)
+
+ res.signature = (ty, types.Any)
+ res.attr = attr
+ return res
+
+
+def fix_returning_optional(context, builder, sig, status, retval):
+ # Reconstruct optional return type
+ if isinstance(sig.return_type, types.Optional):
+ value_type = sig.return_type.type
+ optional_none = context.make_optional_none(builder, value_type)
+ retvalptr = cgutils.alloca_once_value(builder, optional_none)
+ with builder.if_then(builder.not_(status.is_none)):
+ optional_value = context.make_optional_value(
+ builder, value_type, retval,
+ )
+ builder.store(optional_value, retvalptr)
+ retval = builder.load(retvalptr)
+ return retval
+
+def user_function(fndesc, libs):
+ """
+ A wrapper inserting code calling Numba-compiled *fndesc*.
+ """
+
+ def imp(context, builder, sig, args):
+ func = context.declare_function(builder.module, fndesc)
+ # env=None assumes this is a nopython function
+ status, retval = context.call_conv.call_function(
+ builder, func, fndesc.restype, fndesc.argtypes, args)
+ with cgutils.if_unlikely(builder, status.is_error):
+ context.call_conv.return_status_propagate(builder, status)
+ assert sig.return_type == fndesc.restype
+ # Reconstruct optional return type
+ retval = fix_returning_optional(context, builder, sig, status, retval)
+ # If the data representations don't match up
+ if retval.type != context.get_value_type(sig.return_type):
+ msg = "function returned {0} but expect {1}"
+ raise TypeError(msg.format(retval.type, sig.return_type))
+
+ return impl_ret_new_ref(context, builder, fndesc.restype, retval)
+
+ imp.signature = fndesc.argtypes
+ imp.libs = tuple(libs)
+ return imp
+
+
+def user_generator(gendesc, libs):
+ """
+ A wrapper inserting code calling Numba-compiled *gendesc*.
+ """
+
+ def imp(context, builder, sig, args):
+ func = context.declare_function(builder.module, gendesc)
+ # env=None assumes this is a nopython function
+ status, retval = context.call_conv.call_function(
+ builder, func, gendesc.restype, gendesc.argtypes, args)
+ # Return raw status for caller to process StopIteration
+ return status, retval
+
+ imp.libs = tuple(libs)
+ return imp
+
+
+def iterator_impl(iterable_type, iterator_type):
+ """
+ Decorator a given class as implementing *iterator_type*
+ (by providing an `iternext()` method).
+ """
+
+ def wrapper(cls):
+ # These are unbound methods
+ iternext = cls.iternext
+
+ @iternext_impl(RefType.BORROWED)
+ def iternext_wrapper(context, builder, sig, args, result):
+ (value,) = args
+ iterobj = cls(context, builder, value)
+ return iternext(iterobj, context, builder, result)
+
+ lower_builtin('iternext', iterator_type)(iternext_wrapper)
+ return cls
+
+ return wrapper
+
+
+class _IternextResult(object):
+ """
+ A result wrapper for iteration, passed by iternext_impl() into the
+ wrapped function.
+ """
+ __slots__ = ('_context', '_builder', '_pairobj')
+
+ def __init__(self, context, builder, pairobj):
+ self._context = context
+ self._builder = builder
+ self._pairobj = pairobj
+
+ def set_exhausted(self):
+ """
+ Mark the iterator as exhausted.
+ """
+ self._pairobj.second = self._context.get_constant(types.boolean, False)
+
+ def set_valid(self, is_valid=True):
+ """
+ Mark the iterator as valid according to *is_valid* (which must
+ be either a Python boolean or a LLVM inst).
+ """
+ if is_valid in (False, True):
+ is_valid = self._context.get_constant(types.boolean, is_valid)
+ self._pairobj.second = is_valid
+
+ def yield_(self, value):
+ """
+ Mark the iterator as yielding the given *value* (a LLVM inst).
+ """
+ self._pairobj.first = value
+
+ def is_valid(self):
+ """
+ Return whether the iterator is marked valid.
+ """
+ return self._context.get_argument_value(self._builder,
+ types.boolean,
+ self._pairobj.second)
+
+ def yielded_value(self):
+ """
+ Return the iterator's yielded value, if any.
+ """
+ return self._pairobj.first
+
+class RefType(Enum):
+ """
+ Enumerate the reference type
+ """
+ """
+ A new reference
+ """
+ NEW = 1
+ """
+ A borrowed reference
+ """
+ BORROWED = 2
+ """
+ An untracked reference
+ """
+ UNTRACKED = 3
+
+def iternext_impl(ref_type=None):
+ """
+ Wrap the given iternext() implementation so that it gets passed
+ an _IternextResult() object easing the returning of the iternext()
+ result pair.
+
+ ref_type: a numba.targets.imputils.RefType value, the reference type used is
+ that specified through the RefType enum.
+
+ The wrapped function will be called with the following signature:
+ (context, builder, sig, args, iternext_result)
+ """
+ if ref_type not in [x for x in RefType]:
+ raise ValueError("ref_type must be an enum member of imputils.RefType")
+
+ def outer(func):
+ def wrapper(context, builder, sig, args):
+ pair_type = sig.return_type
+ pairobj = context.make_helper(builder, pair_type)
+ func(context, builder, sig, args,
+ _IternextResult(context, builder, pairobj))
+ if ref_type == RefType.NEW:
+ impl_ret = impl_ret_new_ref
+ elif ref_type == RefType.BORROWED:
+ impl_ret = impl_ret_borrowed
+ elif ref_type == RefType.UNTRACKED:
+ impl_ret = impl_ret_untracked
+ else:
+ raise ValueError("Unknown ref_type encountered")
+ return impl_ret(context, builder,
+ pair_type, pairobj._getvalue())
+ return wrapper
+ return outer
+
+
+def call_getiter(context, builder, iterable_type, val):
+ """
+ Call the `getiter()` implementation for the given *iterable_type*
+ of value *val*, and return the corresponding LLVM inst.
+ """
+ getiter_sig = typing.signature(iterable_type.iterator_type, iterable_type)
+ getiter_impl = context.get_function('getiter', getiter_sig)
+ return getiter_impl(builder, (val,))
+
+
+def call_iternext(context, builder, iterator_type, val):
+ """
+ Call the `iternext()` implementation for the given *iterator_type*
+ of value *val*, and return a convenience _IternextResult() object
+ reflecting the results.
+ """
+ itemty = iterator_type.yield_type
+ pair_type = types.Pair(itemty, types.boolean)
+ iternext_sig = typing.signature(pair_type, iterator_type)
+ iternext_impl = context.get_function('iternext', iternext_sig)
+ val = iternext_impl(builder, (val,))
+ pairobj = context.make_helper(builder, pair_type, val)
+ return _IternextResult(context, builder, pairobj)
+
+
+def call_len(context, builder, ty, val):
+ """
+ Call len() on the given value. Return None if len() isn't defined on
+ this type.
+ """
+ try:
+ len_impl = context.get_function(len, typing.signature(types.intp, ty,))
+ except NotImplementedError:
+ return None
+ else:
+ return len_impl(builder, (val,))
+
+
+_ForIterLoop = collections.namedtuple('_ForIterLoop',
+ ('value', 'do_break'))
+
+
+@contextlib.contextmanager
+def for_iter(context, builder, iterable_type, val):
+ """
+ Simulate a for loop on the given iterable. Yields a namedtuple with
+ the given members:
+ - `value` is the value being yielded
+ - `do_break` is a callable to early out of the loop
+ """
+ iterator_type = iterable_type.iterator_type
+ iterval = call_getiter(context, builder, iterable_type, val)
+
+ bb_body = builder.append_basic_block('for_iter.body')
+ bb_end = builder.append_basic_block('for_iter.end')
+
+ def do_break():
+ builder.branch(bb_end)
+
+ builder.branch(bb_body)
+
+ with builder.goto_block(bb_body):
+ res = call_iternext(context, builder, iterator_type, iterval)
+ with builder.if_then(builder.not_(res.is_valid()), likely=False):
+ builder.branch(bb_end)
+ yield _ForIterLoop(res.yielded_value(), do_break)
+ builder.branch(bb_body)
+
+ builder.position_at_end(bb_end)
+ if context.enable_nrt:
+ context.nrt.decref(builder, iterator_type, iterval)
+
+
+def impl_ret_new_ref(ctx, builder, retty, ret):
+ """
+ The implementation returns a new reference.
+ """
+ return ret
+
+
+def impl_ret_borrowed(ctx, builder, retty, ret):
+ """
+ The implementation returns a borrowed reference.
+ This function automatically incref so that the implementation is
+ returning a new reference.
+ """
+ if ctx.enable_nrt:
+ ctx.nrt.incref(builder, retty, ret)
+ return ret
+
+
+def impl_ret_untracked(ctx, builder, retty, ret):
+ """
+ The return type is not a NRT object.
+ """
+ return ret
+
+
+@contextlib.contextmanager
+def force_error_model(context, model_name='numpy'):
+ """
+ Temporarily change the context's error model.
+ """
+ from numba.core import callconv
+
+ old_error_model = context.error_model
+ context.error_model = callconv.create_error_model(model_name, context)
+ try:
+ yield
+ finally:
+ context.error_model = old_error_model
+
+
+def numba_typeref_ctor(*args, **kwargs):
+ """A stub for use internally by Numba when a call is emitted
+ on a TypeRef.
+ """
+ raise NotImplementedError("This function should not be executed.")
diff --git a/venv/lib/python3.10/site-packages/numba/core/inline_closurecall.py b/venv/lib/python3.10/site-packages/numba/core/inline_closurecall.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e5e3b50bebd8725529701c1855b9a85a7836eac
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/inline_closurecall.py
@@ -0,0 +1,1682 @@
+import types as pytypes # avoid confusion with numba.types
+import copy
+import ctypes
+import numba.core.analysis
+from numba.core import (types, typing, errors, ir, rewrites, config, ir_utils,
+ cgutils)
+from numba.parfors.parfor import internal_prange
+from numba.core.ir_utils import (
+ next_label,
+ add_offset_to_labels,
+ replace_vars,
+ remove_dels,
+ rename_labels,
+ find_topo_order,
+ merge_adjacent_blocks,
+ GuardException,
+ require,
+ guard,
+ get_definition,
+ find_callname,
+ find_build_sequence,
+ get_np_ufunc_typ,
+ get_ir_of_code,
+ simplify_CFG,
+ canonicalize_array_math,
+ dead_code_elimination,
+)
+
+from numba.core.analysis import (
+ compute_cfg_from_blocks,
+ compute_use_defs,
+ compute_live_variables)
+from numba.core.imputils import impl_ret_untracked
+from numba.core.extending import intrinsic
+from numba.core.typing import signature
+from numba.cpython.listobj import ListIterInstance
+from numba.cpython.rangeobj import range_impl_map
+from numba.np.arrayobj import make_array
+
+from numba.core import postproc
+from numba.np.unsafe.ndarray import empty_inferred as unsafe_empty_inferred
+import numpy as np
+import operator
+import numba.misc.special
+
+"""
+Variable enable_inline_arraycall is only used for testing purpose.
+"""
+enable_inline_arraycall = True
+
+
+def callee_ir_validator(func_ir):
+ """Checks the IR of a callee is supported for inlining
+ """
+ for blk in func_ir.blocks.values():
+ for stmt in blk.find_insts(ir.Assign):
+ if isinstance(stmt.value, ir.Yield):
+ msg = "The use of yield in a closure is unsupported."
+ raise errors.UnsupportedError(msg, loc=stmt.loc)
+
+
+def _created_inlined_var_name(function_name, var_name):
+ """Creates a name for an inlined variable based on the function name and the
+ variable name. It does this "safely" to avoid the use of characters that are
+ illegal in python variable names as there are occasions when function
+ generation needs valid python name tokens."""
+ inlined_name = f'{function_name}.{var_name}'
+ # Replace angle brackets, e.g. "" is replaced with "_locals_"
+ new_name = inlined_name.replace('<', '_').replace('>', '_')
+ # The version "version" of the closure function e.g. foo$2 (id 2) is
+ # rewritten as "foo_v2". Further "." is also replaced with "_".
+ new_name = new_name.replace('.', '_').replace('$', '_v')
+ return new_name
+
+
+class InlineClosureCallPass(object):
+ """InlineClosureCallPass class looks for direct calls to locally defined
+ closures, and inlines the body of the closure function to the call site.
+ """
+
+ def __init__(self, func_ir, parallel_options, swapped={}, typed=False):
+ self.func_ir = func_ir
+ self.parallel_options = parallel_options
+ self.swapped = swapped
+ self._processed_stencils = []
+ self.typed = typed
+
+ def run(self):
+ """Run inline closure call pass.
+ """
+ # Analysis relies on ir.Del presence, strip out later
+ pp = postproc.PostProcessor(self.func_ir)
+ pp.run(True)
+
+ modified = False
+ work_list = list(self.func_ir.blocks.items())
+ debug_print = _make_debug_print("InlineClosureCallPass")
+ debug_print(f"START {self.func_ir.func_id.func_qualname}")
+ while work_list:
+ _label, block = work_list.pop()
+ for i, instr in enumerate(block.body):
+ if isinstance(instr, ir.Assign):
+ expr = instr.value
+ if isinstance(expr, ir.Expr) and expr.op == 'call':
+ call_name = guard(find_callname, self.func_ir, expr)
+ func_def = guard(get_definition, self.func_ir,
+ expr.func)
+
+ if guard(self._inline_reduction,
+ work_list, block, i, expr, call_name):
+ modified = True
+ break # because block structure changed
+
+ if guard(self._inline_closure,
+ work_list, block, i, func_def):
+ modified = True
+ break # because block structure changed
+
+ if guard(self._inline_stencil,
+ instr, call_name, func_def):
+ modified = True
+
+ if enable_inline_arraycall:
+ # Identify loop structure
+ if modified:
+ # Need to do some cleanups if closure inlining kicked in
+ merge_adjacent_blocks(self.func_ir.blocks)
+ cfg = compute_cfg_from_blocks(self.func_ir.blocks)
+ debug_print("start inline arraycall")
+ _debug_dump(cfg)
+ loops = cfg.loops()
+ sized_loops = [(k, len(loops[k].body)) for k in loops.keys()]
+ visited = []
+ # We go over all loops, bigger loops first (outer first)
+ for k, s in sorted(sized_loops, key=lambda tup: tup[1],
+ reverse=True):
+ visited.append(k)
+ if guard(_inline_arraycall, self.func_ir, cfg, visited,
+ loops[k], self.swapped,
+ self.parallel_options.comprehension, self.typed):
+ modified = True
+ if modified:
+ _fix_nested_array(self.func_ir)
+
+ if modified:
+ # clean up now dead/unreachable blocks, e.g. unconditionally raising
+ # an exception in an inlined function would render some parts of the
+ # inliner unreachable
+ cfg = compute_cfg_from_blocks(self.func_ir.blocks)
+ for dead in cfg.dead_nodes():
+ del self.func_ir.blocks[dead]
+
+ # run dead code elimination
+ dead_code_elimination(self.func_ir)
+ # do label renaming
+ self.func_ir.blocks = rename_labels(self.func_ir.blocks)
+
+ # inlining done, strip dels
+ remove_dels(self.func_ir.blocks)
+
+ debug_print("END")
+
+ def _inline_reduction(self, work_list, block, i, expr, call_name):
+ # only inline reduction in sequential execution, parallel handling
+ # is done in ParforPass.
+ require(not self.parallel_options.reduction)
+ require(call_name == ('reduce', 'builtins') or
+ call_name == ('reduce', '_functools'))
+ if len(expr.args) not in (2, 3):
+ raise TypeError("invalid reduce call, "
+ "two arguments are required (optional initial "
+ "value can also be specified)")
+ check_reduce_func(self.func_ir, expr.args[0])
+
+ def reduce_func(f, A, v=None):
+ it = iter(A)
+ if v is not None:
+ s = v
+ else:
+ s = next(it)
+ for a in it:
+ s = f(s, a)
+ return s
+
+ inline_closure_call(
+ self.func_ir, self.func_ir.func_id.func.__globals__,
+ block, i, reduce_func, work_list=work_list,
+ callee_validator=callee_ir_validator
+ )
+ return True
+
+ def _inline_stencil(self, instr, call_name, func_def):
+ from numba.stencils.stencil import StencilFunc
+ lhs = instr.target
+ expr = instr.value
+ # We keep the escaping variables of the stencil kernel
+ # alive by adding them to the actual kernel call as extra
+ # keyword arguments, which is ignored anyway.
+ if (isinstance(func_def, ir.Global) and
+ func_def.name == 'stencil' and
+ isinstance(func_def.value, StencilFunc)):
+ if expr.kws:
+ expr.kws += func_def.value.kws
+ else:
+ expr.kws = func_def.value.kws
+ return True
+ # Otherwise we proceed to check if it is a call to numba.stencil
+ require(call_name == ('stencil', 'numba.stencils.stencil') or
+ call_name == ('stencil', 'numba'))
+ require(expr not in self._processed_stencils)
+ self._processed_stencils.append(expr)
+ if not len(expr.args) == 1:
+ raise ValueError("As a minimum Stencil requires"
+ " a kernel as an argument")
+ stencil_def = guard(get_definition, self.func_ir, expr.args[0])
+ require(isinstance(stencil_def, ir.Expr) and
+ stencil_def.op == "make_function")
+ kernel_ir = get_ir_of_code(self.func_ir.func_id.func.__globals__,
+ stencil_def.code)
+ options = dict(expr.kws)
+ if 'neighborhood' in options:
+ fixed = guard(self._fix_stencil_neighborhood, options)
+ if not fixed:
+ raise ValueError(
+ "stencil neighborhood option should be a tuple"
+ " with constant structure such as ((-w, w),)"
+ )
+ if 'index_offsets' in options:
+ fixed = guard(self._fix_stencil_index_offsets, options)
+ if not fixed:
+ raise ValueError(
+ "stencil index_offsets option should be a tuple"
+ " with constant structure such as (offset, )"
+ )
+ sf = StencilFunc(kernel_ir, 'constant', options)
+ sf.kws = expr.kws # hack to keep variables live
+ sf_global = ir.Global('stencil', sf, expr.loc)
+ self.func_ir._definitions[lhs.name] = [sf_global]
+ instr.value = sf_global
+ return True
+
+ def _fix_stencil_neighborhood(self, options):
+ """
+ Extract the two-level tuple representing the stencil neighborhood
+ from the program IR to provide a tuple to StencilFunc.
+ """
+ # build_tuple node with neighborhood for each dimension
+ dims_build_tuple = get_definition(self.func_ir, options['neighborhood'])
+ require(hasattr(dims_build_tuple, 'items'))
+ res = []
+ for window_var in dims_build_tuple.items:
+ win_build_tuple = get_definition(self.func_ir, window_var)
+ require(hasattr(win_build_tuple, 'items'))
+ res.append(tuple(win_build_tuple.items))
+ options['neighborhood'] = tuple(res)
+ return True
+
+ def _fix_stencil_index_offsets(self, options):
+ """
+ Extract the tuple representing the stencil index offsets
+ from the program IR to provide to StencilFunc.
+ """
+ offset_tuple = get_definition(self.func_ir, options['index_offsets'])
+ require(hasattr(offset_tuple, 'items'))
+ options['index_offsets'] = tuple(offset_tuple.items)
+ return True
+
+ def _inline_closure(self, work_list, block, i, func_def):
+ require(isinstance(func_def, ir.Expr) and
+ func_def.op == "make_function")
+ inline_closure_call(self.func_ir,
+ self.func_ir.func_id.func.__globals__,
+ block, i, func_def, work_list=work_list,
+ callee_validator=callee_ir_validator)
+ return True
+
+
+def check_reduce_func(func_ir, func_var):
+ """Checks the function at func_var in func_ir to make sure it's amenable
+ for inlining. Returns the function itself"""
+ reduce_func = guard(get_definition, func_ir, func_var)
+ if reduce_func is None:
+ raise ValueError("Reduce function cannot be found for njit \
+ analysis")
+ if isinstance(reduce_func, (ir.FreeVar, ir.Global)):
+ if not isinstance(reduce_func.value,
+ numba.core.registry.CPUDispatcher):
+ raise ValueError("Invalid reduction function")
+ # pull out the python function for inlining
+ reduce_func = reduce_func.value.py_func
+ elif not (hasattr(reduce_func, 'code')
+ or hasattr(reduce_func, '__code__')):
+ raise ValueError("Invalid reduction function")
+ f_code = (reduce_func.code
+ if hasattr(reduce_func, 'code')
+ else reduce_func.__code__)
+ if not f_code.co_argcount == 2:
+ raise TypeError("Reduction function should take 2 arguments")
+ return reduce_func
+
+
+class InlineWorker(object):
+ """ A worker class for inlining, this is a more advanced version of
+ `inline_closure_call` in that it permits inlining from function type, Numba
+ IR and code object. It also, runs the entire untyped compiler pipeline on
+ the inlinee to ensure that it is transformed as though it were compiled
+ directly.
+ """
+
+ def __init__(self,
+ typingctx=None,
+ targetctx=None,
+ locals=None,
+ pipeline=None,
+ flags=None,
+ validator=callee_ir_validator,
+ typemap=None,
+ calltypes=None):
+ """
+ Instantiate a new InlineWorker, all arguments are optional though some
+ must be supplied together for certain use cases. The methods will refuse
+ to run if the object isn't configured in the manner needed. Args are the
+ same as those in a numba.core.Compiler.state, except the validator which
+ is a function taking Numba IR and validating it for use when inlining
+ (this is optional and really to just provide better error messages about
+ things which the inliner cannot handle like yield in closure).
+ """
+ def check(arg, name):
+ if arg is None:
+ raise TypeError("{} must not be None".format(name))
+
+ from numba.core.compiler import DefaultPassBuilder
+
+ # check the stuff needed to run the more advanced compilation pipeline
+ # is valid if any of it is provided
+ compiler_args = (targetctx, locals, pipeline, flags)
+ compiler_group = [x is not None for x in compiler_args]
+ if any(compiler_group) and not all(compiler_group):
+ check(targetctx, 'targetctx')
+ check(locals, 'locals')
+ check(pipeline, 'pipeline')
+ check(flags, 'flags')
+ elif all(compiler_group):
+ check(typingctx, 'typingctx')
+
+ self._compiler_pipeline = DefaultPassBuilder.define_untyped_pipeline
+
+ self.typingctx = typingctx
+ self.targetctx = targetctx
+ self.locals = locals
+ self.pipeline = pipeline
+ self.flags = flags
+ self.validator = validator
+ self.debug_print = _make_debug_print("InlineWorker")
+
+ # check whether this inliner can also support typemap and calltypes
+ # update and if what's provided is valid
+ pair = (typemap, calltypes)
+ pair_is_none = [x is None for x in pair]
+ if any(pair_is_none) and not all(pair_is_none):
+ msg = ("typemap and calltypes must both be either None or have a "
+ "value, got: %s, %s")
+ raise TypeError(msg % pair)
+ self._permit_update_type_and_call_maps = not all(pair_is_none)
+ self.typemap = typemap
+ self.calltypes = calltypes
+
+ def inline_ir(self, caller_ir, block, i, callee_ir, callee_freevars,
+ arg_typs=None):
+ """ Inlines the callee_ir in the caller_ir at statement index i of block
+ `block`, callee_freevars are the free variables for the callee_ir. If
+ the callee_ir is derived from a function `func` then this is
+ `func.__code__.co_freevars`. If `arg_typs` is given and the InlineWorker
+ instance was initialized with a typemap and calltypes then they will be
+ appropriately updated based on the arg_typs.
+ """
+
+ # Always copy the callee IR, it gets mutated
+ def copy_ir(the_ir):
+ kernel_copy = the_ir.copy()
+ kernel_copy.blocks = {}
+ for block_label, block in the_ir.blocks.items():
+ new_block = copy.deepcopy(the_ir.blocks[block_label])
+ kernel_copy.blocks[block_label] = new_block
+ return kernel_copy
+
+ callee_ir = copy_ir(callee_ir)
+
+ # check that the contents of the callee IR is something that can be
+ # inlined if a validator is present
+ if self.validator is not None:
+ self.validator(callee_ir)
+
+ # save an unmutated copy of the callee_ir to return
+ callee_ir_original = copy_ir(callee_ir)
+ scope = block.scope
+ instr = block.body[i]
+ call_expr = instr.value
+ callee_blocks = callee_ir.blocks
+
+ # 1. relabel callee_ir by adding an offset
+ max_label = max(
+ ir_utils._the_max_label.next(),
+ max(caller_ir.blocks.keys()),
+ )
+ callee_blocks = add_offset_to_labels(callee_blocks, max_label + 1)
+ callee_blocks = simplify_CFG(callee_blocks)
+ callee_ir.blocks = callee_blocks
+ min_label = min(callee_blocks.keys())
+ max_label = max(callee_blocks.keys())
+ # reset globals in ir_utils before we use it
+ ir_utils._the_max_label.update(max_label)
+ self.debug_print("After relabel")
+ _debug_dump(callee_ir)
+
+ # 2. rename all local variables in callee_ir with new locals created in
+ # caller_ir
+ callee_scopes = _get_all_scopes(callee_blocks)
+ self.debug_print("callee_scopes = ", callee_scopes)
+ # one function should only have one local scope
+ assert (len(callee_scopes) == 1)
+ callee_scope = callee_scopes[0]
+ var_dict = {}
+ for var in tuple(callee_scope.localvars._con.values()):
+ if not (var.name in callee_freevars):
+ inlined_name = _created_inlined_var_name(
+ callee_ir.func_id.unique_name, var.name)
+ # Update the caller scope with the new names
+ new_var = scope.redefine(inlined_name, loc=var.loc)
+ # Also update the callee scope with the new names. Should the
+ # type and call maps need updating (which requires SSA form) the
+ # transformation to SSA is valid as the IR object is internally
+ # consistent.
+ callee_scope.redefine(inlined_name, loc=var.loc)
+ var_dict[var.name] = new_var
+ self.debug_print("var_dict = ", var_dict)
+ replace_vars(callee_blocks, var_dict)
+ self.debug_print("After local var rename")
+ _debug_dump(callee_ir)
+
+ # 3. replace formal parameters with actual arguments
+ callee_func = callee_ir.func_id.func
+ args = _get_callee_args(call_expr, callee_func, block.body[i].loc,
+ caller_ir)
+
+ # 4. Update typemap
+ if self._permit_update_type_and_call_maps:
+ if arg_typs is None:
+ raise TypeError('arg_typs should have a value not None')
+ self.update_type_and_call_maps(callee_ir, arg_typs)
+ # update_type_and_call_maps replaces blocks
+ callee_blocks = callee_ir.blocks
+
+ self.debug_print("After arguments rename: ")
+ _debug_dump(callee_ir)
+
+ _replace_args_with(callee_blocks, args)
+ # 5. split caller blocks into two
+ new_blocks = []
+ new_block = ir.Block(scope, block.loc)
+ new_block.body = block.body[i + 1:]
+ new_label = next_label()
+ caller_ir.blocks[new_label] = new_block
+ new_blocks.append((new_label, new_block))
+ block.body = block.body[:i]
+ block.body.append(ir.Jump(min_label, instr.loc))
+
+ # 6. replace Return with assignment to LHS
+ topo_order = find_topo_order(callee_blocks)
+ _replace_returns(callee_blocks, instr.target, new_label)
+
+ # remove the old definition of instr.target too
+ if (instr.target.name in caller_ir._definitions
+ and call_expr in caller_ir._definitions[instr.target.name]):
+ # NOTE: target can have multiple definitions due to control flow
+ caller_ir._definitions[instr.target.name].remove(call_expr)
+
+ # 7. insert all new blocks, and add back definitions
+ for label in topo_order:
+ # block scope must point to parent's
+ block = callee_blocks[label]
+ block.scope = scope
+ _add_definitions(caller_ir, block)
+ caller_ir.blocks[label] = block
+ new_blocks.append((label, block))
+ self.debug_print("After merge in")
+ _debug_dump(caller_ir)
+
+ return callee_ir_original, callee_blocks, var_dict, new_blocks
+
+ def inline_function(self, caller_ir, block, i, function, arg_typs=None):
+ """ Inlines the function in the caller_ir at statement index i of block
+ `block`. If `arg_typs` is given and the InlineWorker instance was
+ initialized with a typemap and calltypes then they will be appropriately
+ updated based on the arg_typs.
+ """
+ callee_ir = self.run_untyped_passes(function)
+ freevars = function.__code__.co_freevars
+ return self.inline_ir(caller_ir, block, i, callee_ir, freevars,
+ arg_typs=arg_typs)
+
+ def run_untyped_passes(self, func, enable_ssa=False):
+ """
+ Run the compiler frontend's untyped passes over the given Python
+ function, and return the function's canonical Numba IR.
+
+ Disable SSA transformation by default, since the call site won't be in
+ SSA form and self.inline_ir depends on this being the case.
+ """
+ from numba.core.compiler import StateDict, _CompileStatus
+ from numba.core.untyped_passes import ExtractByteCode
+ from numba.core import bytecode
+ from numba.parfors.parfor import ParforDiagnostics
+ state = StateDict()
+ state.func_ir = None
+ state.typingctx = self.typingctx
+ state.targetctx = self.targetctx
+ state.locals = self.locals
+ state.pipeline = self.pipeline
+ state.flags = self.flags
+ state.flags.enable_ssa = enable_ssa
+
+ state.func_id = bytecode.FunctionIdentity.from_function(func)
+
+ state.typemap = None
+ state.calltypes = None
+ state.type_annotation = None
+ state.status = _CompileStatus(False)
+ state.return_type = None
+ state.parfor_diagnostics = ParforDiagnostics()
+ state.metadata = {}
+
+ ExtractByteCode().run_pass(state)
+ # This is a lie, just need *some* args for the case where an obj mode
+ # with lift is needed
+ state.args = len(state.bc.func_id.pysig.parameters) * (types.pyobject,)
+
+ pm = self._compiler_pipeline(state)
+
+ pm.finalize()
+ pm.run(state)
+ return state.func_ir
+
+ def update_type_and_call_maps(self, callee_ir, arg_typs):
+ """ Updates the type and call maps based on calling callee_ir with
+ arguments from arg_typs"""
+ from numba.core.ssa import reconstruct_ssa
+ from numba.core.typed_passes import PreLowerStripPhis
+
+ if not self._permit_update_type_and_call_maps:
+ msg = ("InlineWorker instance not configured correctly, typemap or "
+ "calltypes missing in initialization.")
+ raise ValueError(msg)
+ from numba.core import typed_passes
+ # call branch pruning to simplify IR and avoid inference errors
+ callee_ir._definitions = ir_utils.build_definitions(callee_ir.blocks)
+ numba.core.analysis.dead_branch_prune(callee_ir, arg_typs)
+ # callee's typing may require SSA
+ callee_ir = reconstruct_ssa(callee_ir)
+ callee_ir._definitions = ir_utils.build_definitions(callee_ir.blocks)
+ [f_typemap,
+ _f_return_type,
+ f_calltypes, _] = typed_passes.type_inference_stage(
+ self.typingctx, self.targetctx, callee_ir, arg_typs, None,
+ )
+ callee_ir = PreLowerStripPhis()._strip_phi_nodes(callee_ir)
+ callee_ir._definitions = ir_utils.build_definitions(callee_ir.blocks)
+ canonicalize_array_math(callee_ir, f_typemap,
+ f_calltypes, self.typingctx)
+ # remove argument entries like arg.a from typemap
+ arg_names = [vname for vname in f_typemap if vname.startswith("arg.")]
+ for a in arg_names:
+ f_typemap.pop(a)
+ self.typemap.update(f_typemap)
+ self.calltypes.update(f_calltypes)
+
+
+def inline_closure_call(func_ir, glbls, block, i, callee, typingctx=None,
+ targetctx=None, arg_typs=None, typemap=None,
+ calltypes=None, work_list=None, callee_validator=None,
+ replace_freevars=True):
+ """Inline the body of `callee` at its callsite (`i`-th instruction of
+ `block`)
+
+ `func_ir` is the func_ir object of the caller function and `glbls` is its
+ global variable environment (func_ir.func_id.func.__globals__).
+ `block` is the IR block of the callsite and `i` is the index of the
+ callsite's node. `callee` is either the called function or a
+ make_function node. `typingctx`, `typemap` and `calltypes` are typing
+ data structures of the caller, available if we are in a typed pass.
+ `arg_typs` includes the types of the arguments at the callsite.
+ `callee_validator` is an optional callable which can be used to validate the
+ IR of the callee to ensure that it contains IR supported for inlining, it
+ takes one argument, the func_ir of the callee
+
+ Returns IR blocks of the callee and the variable renaming dictionary used
+ for them to facilitate further processing of new blocks.
+ """
+ scope = block.scope
+ instr = block.body[i]
+ call_expr = instr.value
+ debug_print = _make_debug_print("inline_closure_call")
+ debug_print("Found closure call: ", instr, " with callee = ", callee)
+ # support both function object and make_function Expr
+ callee_code = callee.code if hasattr(callee, 'code') else callee.__code__
+ callee_closure = (callee.closure
+ if hasattr(callee, 'closure') else callee.__closure__)
+ # first, get the IR of the callee
+ if isinstance(callee, pytypes.FunctionType):
+ from numba.core import compiler
+ callee_ir = compiler.run_frontend(callee, inline_closures=True)
+ else:
+ callee_ir = get_ir_of_code(glbls, callee_code)
+
+ # check that the contents of the callee IR is something that can be inlined
+ # if a validator is supplied
+ if callee_validator is not None:
+ callee_validator(callee_ir)
+
+ callee_blocks = callee_ir.blocks
+
+ # 1. relabel callee_ir by adding an offset
+ max_label = max(ir_utils._the_max_label.next(), max(func_ir.blocks.keys()))
+ callee_blocks = add_offset_to_labels(callee_blocks, max_label + 1)
+ callee_blocks = simplify_CFG(callee_blocks)
+ callee_ir.blocks = callee_blocks
+ min_label = min(callee_blocks.keys())
+ max_label = max(callee_blocks.keys())
+ # reset globals in ir_utils before we use it
+ ir_utils._the_max_label.update(max_label)
+ debug_print("After relabel")
+ _debug_dump(callee_ir)
+
+ # 2. rename all local variables in callee_ir with new locals created in
+ # func_ir
+ callee_scopes = _get_all_scopes(callee_blocks)
+ debug_print("callee_scopes = ", callee_scopes)
+ # one function should only have one local scope
+ assert (len(callee_scopes) == 1)
+ callee_scope = callee_scopes[0]
+ var_dict = {}
+ for var in callee_scope.localvars._con.values():
+ if not (var.name in callee_code.co_freevars):
+ inlined_name = _created_inlined_var_name(
+ callee_ir.func_id.unique_name, var.name)
+ new_var = scope.redefine(inlined_name, loc=var.loc)
+ var_dict[var.name] = new_var
+ debug_print("var_dict = ", var_dict)
+ replace_vars(callee_blocks, var_dict)
+ debug_print("After local var rename")
+ _debug_dump(callee_ir)
+
+ # 3. replace formal parameters with actual arguments
+ args = _get_callee_args(call_expr, callee, block.body[i].loc, func_ir)
+
+ debug_print("After arguments rename: ")
+ _debug_dump(callee_ir)
+
+ # 4. replace freevar with actual closure var
+ if callee_closure and replace_freevars:
+ closure = func_ir.get_definition(callee_closure)
+ debug_print("callee's closure = ", closure)
+ if isinstance(closure, tuple):
+ cellget = ctypes.pythonapi.PyCell_Get
+ cellget.restype = ctypes.py_object
+ cellget.argtypes = (ctypes.py_object,)
+ items = tuple(cellget(x) for x in closure)
+ else:
+ assert (isinstance(closure, ir.Expr)
+ and closure.op == 'build_tuple')
+ items = closure.items
+ assert (len(callee_code.co_freevars) == len(items))
+ _replace_freevars(callee_blocks, items)
+ debug_print("After closure rename")
+ _debug_dump(callee_ir)
+
+ if typingctx:
+ from numba.core import typed_passes
+ # call branch pruning to simplify IR and avoid inference errors
+ callee_ir._definitions = ir_utils.build_definitions(callee_ir.blocks)
+ numba.core.analysis.dead_branch_prune(callee_ir, arg_typs)
+ try:
+ [f_typemap, f_return_type,
+ f_calltypes, _] = typed_passes.type_inference_stage(
+ typingctx, targetctx, callee_ir, arg_typs, None)
+ except Exception:
+ [f_typemap, f_return_type,
+ f_calltypes, _] = typed_passes.type_inference_stage(
+ typingctx, targetctx, callee_ir, arg_typs, None)
+ canonicalize_array_math(callee_ir, f_typemap,
+ f_calltypes, typingctx)
+ # remove argument entries like arg.a from typemap
+ arg_names = [vname for vname in f_typemap if vname.startswith("arg.")]
+ for a in arg_names:
+ f_typemap.pop(a)
+ typemap.update(f_typemap)
+ calltypes.update(f_calltypes)
+
+ _replace_args_with(callee_blocks, args)
+ # 5. split caller blocks into two
+ new_blocks = []
+ new_block = ir.Block(scope, block.loc)
+ new_block.body = block.body[i + 1:]
+ new_label = next_label()
+ func_ir.blocks[new_label] = new_block
+ new_blocks.append((new_label, new_block))
+ block.body = block.body[:i]
+ block.body.append(ir.Jump(min_label, instr.loc))
+
+ # 6. replace Return with assignment to LHS
+ topo_order = find_topo_order(callee_blocks)
+ _replace_returns(callee_blocks, instr.target, new_label)
+
+ # remove the old definition of instr.target too
+ if (instr.target.name in func_ir._definitions
+ and call_expr in func_ir._definitions[instr.target.name]):
+ # NOTE: target can have multiple definitions due to control flow
+ func_ir._definitions[instr.target.name].remove(call_expr)
+
+ # 7. insert all new blocks, and add back definitions
+ for label in topo_order:
+ # block scope must point to parent's
+ block = callee_blocks[label]
+ block.scope = scope
+ _add_definitions(func_ir, block)
+ func_ir.blocks[label] = block
+ new_blocks.append((label, block))
+ debug_print("After merge in")
+ _debug_dump(func_ir)
+
+ if work_list is not None:
+ for block in new_blocks:
+ work_list.append(block)
+ return callee_blocks, var_dict
+
+
+def _get_callee_args(call_expr, callee, loc, func_ir):
+ """Get arguments for calling 'callee', including the default arguments.
+ keyword arguments are currently only handled when 'callee' is a function.
+ """
+ if call_expr.op == 'call':
+ args = list(call_expr.args)
+ if call_expr.vararg:
+ msg = "Calling a closure with *args is unsupported."
+ raise errors.UnsupportedError(msg, call_expr.loc)
+ elif call_expr.op == 'getattr':
+ args = [call_expr.value]
+ elif ir_utils.is_operator_or_getitem(call_expr):
+ args = call_expr.list_vars()
+ else:
+ raise TypeError("Unsupported ir.Expr.{}".format(call_expr.op))
+
+ debug_print = _make_debug_print("inline_closure_call default handling")
+
+ # handle defaults and kw arguments using pysignature if callee is function
+ if isinstance(callee, pytypes.FunctionType):
+ pysig = numba.core.utils.pysignature(callee)
+ normal_handler = lambda index, param, default: default
+ default_handler = lambda index, param, default: ir.Const(default, loc)
+
+ # Throw error for stararg
+ # TODO: handle stararg
+ def stararg_handler(index, param, default):
+ raise NotImplementedError(
+ "Stararg not supported in inliner for arg {} {}".format(
+ index, param))
+ if call_expr.op == 'call':
+ kws = dict(call_expr.kws)
+ else:
+ kws = {}
+ return numba.core.typing.fold_arguments(
+ pysig, args, kws, normal_handler, default_handler,
+ stararg_handler)
+ else:
+ # TODO: handle arguments for make_function case similar to function
+ # case above
+ callee_defaults = (callee.defaults if hasattr(callee, 'defaults')
+ else callee.__defaults__)
+ if callee_defaults:
+ debug_print("defaults = ", callee_defaults)
+ if isinstance(callee_defaults, tuple): # Python 3.5
+ defaults_list = []
+ for x in callee_defaults:
+ if isinstance(x, ir.Var):
+ defaults_list.append(x)
+ else:
+ # this branch is predominantly for kwargs from
+ # inlinable functions
+ defaults_list.append(ir.Const(value=x, loc=loc))
+ args = args + defaults_list
+ elif (isinstance(callee_defaults, ir.Var)
+ or isinstance(callee_defaults, str)):
+ default_tuple = func_ir.get_definition(callee_defaults)
+ assert (isinstance(default_tuple, ir.Expr))
+ assert (default_tuple.op == "build_tuple")
+ const_vals = [func_ir.get_definition(x) for
+ x in default_tuple.items]
+ args = args + const_vals
+ else:
+ raise NotImplementedError(
+ "Unsupported defaults to make_function: {}".format(
+ callee_defaults))
+ return args
+
+
+def _make_debug_print(prefix):
+ def debug_print(*args):
+ if config.DEBUG_INLINE_CLOSURE:
+ print(prefix + ": " + "".join(str(x) for x in args))
+ return debug_print
+
+
+def _debug_dump(func_ir):
+ if config.DEBUG_INLINE_CLOSURE:
+ func_ir.dump()
+
+
+def _get_all_scopes(blocks):
+ """Get all block-local scopes from an IR.
+ """
+ all_scopes = []
+ for label, block in blocks.items():
+ if not (block.scope in all_scopes):
+ all_scopes.append(block.scope)
+ return all_scopes
+
+
+def _replace_args_with(blocks, args):
+ """
+ Replace ir.Arg(...) with real arguments from call site
+ """
+ for label, block in blocks.items():
+ assigns = block.find_insts(ir.Assign)
+ for stmt in assigns:
+ if isinstance(stmt.value, ir.Arg):
+ idx = stmt.value.index
+ assert (idx < len(args))
+ stmt.value = args[idx]
+
+
+def _replace_freevars(blocks, args):
+ """
+ Replace ir.FreeVar(...) with real variables from parent function
+ """
+ for label, block in blocks.items():
+ assigns = block.find_insts(ir.Assign)
+ for stmt in assigns:
+ if isinstance(stmt.value, ir.FreeVar):
+ idx = stmt.value.index
+ assert (idx < len(args))
+ if isinstance(args[idx], ir.Var):
+ stmt.value = args[idx]
+ else:
+ stmt.value = ir.Const(args[idx], stmt.loc)
+
+
+def _replace_returns(blocks, target, return_label):
+ """
+ Return return statement by assigning directly to target, and a jump.
+ """
+ for label, block in blocks.items():
+ casts = []
+ for i in range(len(block.body)):
+ stmt = block.body[i]
+ if isinstance(stmt, ir.Return):
+ assert (i + 1 == len(block.body))
+ block.body[i] = ir.Assign(stmt.value, target, stmt.loc)
+ block.body.append(ir.Jump(return_label, stmt.loc))
+ # remove cast of the returned value
+ for cast in casts:
+ if cast.target.name == stmt.value.name:
+ cast.value = cast.value.value
+ elif (isinstance(stmt, ir.Assign) and
+ isinstance(stmt.value, ir.Expr) and
+ stmt.value.op == 'cast'):
+ casts.append(stmt)
+
+
+def _add_definitions(func_ir, block):
+ """
+ Add variable definitions found in a block to parent func_ir.
+ """
+ definitions = func_ir._definitions
+ assigns = block.find_insts(ir.Assign)
+ for stmt in assigns:
+ definitions[stmt.target.name].append(stmt.value)
+
+
+def _find_arraycall(func_ir, block):
+ """Look for statement like "x = numpy.array(y)" or "x[..] = y"
+ immediately after the closure call that creates list y (the i-th
+ statement in block). Return the statement index if found, or
+ raise GuardException.
+ """
+ array_var = None
+ list_var_dead_after_array_call = False
+ list_var = None
+
+ i = 0
+ while i < len(block.body):
+ instr = block.body[i]
+ if isinstance(instr, ir.Del):
+ # Stop the process if list_var becomes dead
+ if list_var and array_var and instr.value == list_var.name:
+ list_var_dead_after_array_call = True
+ break
+ pass
+ elif isinstance(instr, ir.Assign):
+ # Found array_var = array(list_var)
+ lhs = instr.target
+ expr = instr.value
+ if (guard(find_callname, func_ir, expr) == ('array', 'numpy') and
+ isinstance(expr.args[0], ir.Var)):
+ list_var = expr.args[0]
+ array_var = lhs
+ array_stmt_index = i
+ array_kws = dict(expr.kws)
+ elif (isinstance(instr, ir.SetItem) and
+ isinstance(instr.value, ir.Var) and
+ not list_var):
+ list_var = instr.value
+ # Found array_var[..] = list_var, the case for nested array
+ array_var = instr.target
+ array_def = get_definition(func_ir, array_var)
+ require(guard(_find_unsafe_empty_inferred, func_ir, array_def))
+ array_stmt_index = i
+ array_kws = {}
+ else:
+ # Bail out otherwise
+ break
+ i = i + 1
+ # require array_var is found, and list_var is dead after array_call.
+ require(array_var and list_var_dead_after_array_call)
+ _make_debug_print("find_array_call")(block.body[array_stmt_index])
+ return list_var, array_stmt_index, array_kws
+
+
+def _find_iter_range(func_ir, range_iter_var, swapped):
+ """Find the iterator's actual range if it is either range(n), or
+ range(m, n), otherwise return raise GuardException.
+ """
+ debug_print = _make_debug_print("find_iter_range")
+ range_iter_def = get_definition(func_ir, range_iter_var)
+ debug_print("range_iter_var = ", range_iter_var, " def = ", range_iter_def)
+ require(isinstance(range_iter_def, ir.Expr) and
+ range_iter_def.op == 'getiter')
+ range_var = range_iter_def.value
+ range_def = get_definition(func_ir, range_var)
+ debug_print("range_var = ", range_var, " range_def = ", range_def)
+ require(isinstance(range_def, ir.Expr) and range_def.op == 'call')
+ func_var = range_def.func
+ func_def = get_definition(func_ir, func_var)
+ debug_print("func_var = ", func_var, " func_def = ", func_def)
+ require(isinstance(func_def, ir.Global) and
+ (func_def.value == range or
+ func_def.value == numba.misc.special.prange))
+ nargs = len(range_def.args)
+ swapping = [('"array comprehension"', 'closure of'), range_def.func.loc]
+ if nargs == 1:
+ swapped[range_def.func.name] = swapping
+ stop = get_definition(func_ir, range_def.args[0], lhs_only=True)
+ return (0, range_def.args[0], func_def)
+ elif nargs == 2:
+ swapped[range_def.func.name] = swapping
+ start = get_definition(func_ir, range_def.args[0], lhs_only=True)
+ stop = get_definition(func_ir, range_def.args[1], lhs_only=True)
+ return (start, stop, func_def)
+ else:
+ raise GuardException
+
+
+@intrinsic
+def length_of_iterator(typingctx, val):
+ """
+ An implementation of len(iter) for internal use.
+ Primary use is for array comprehensions (see inline_closurecall).
+ """
+ if isinstance(val, types.RangeIteratorType):
+ val_type = val.yield_type
+
+ def codegen(context, builder, sig, args):
+ (value,) = args
+ iter_type = range_impl_map[val_type][1]
+ iterobj = cgutils.create_struct_proxy(iter_type)(context, builder,
+ value)
+ int_type = iterobj.count.type
+ return impl_ret_untracked(context, builder, int_type,
+ builder.load(iterobj.count))
+ return signature(val_type, val), codegen
+ elif isinstance(val, types.ListIter):
+ def codegen(context, builder, sig, args):
+ (value,) = args
+ intp_t = context.get_value_type(types.intp)
+ iterobj = ListIterInstance(context, builder, sig.args[0], value)
+ return impl_ret_untracked(context, builder, intp_t, iterobj.size)
+ return signature(types.intp, val), codegen
+ elif isinstance(val, types.ArrayIterator):
+ def codegen(context, builder, sig, args):
+ (iterty,) = sig.args
+ (value,) = args
+ intp_t = context.get_value_type(types.intp)
+ iterobj = context.make_helper(builder, iterty, value=value)
+ arrayty = iterty.array_type
+ ary = make_array(arrayty)(context, builder, value=iterobj.array)
+ shape = cgutils.unpack_tuple(builder, ary.shape)
+ # array iterates along the outer dimension
+ return impl_ret_untracked(context, builder, intp_t, shape[0])
+ return signature(types.intp, val), codegen
+ elif isinstance(val, types.UniTupleIter):
+ def codegen(context, builder, sig, args):
+ (iterty,) = sig.args
+ tuplety = iterty.container
+ intp_t = context.get_value_type(types.intp)
+ count_const = intp_t(tuplety.count)
+ return impl_ret_untracked(context, builder, intp_t, count_const)
+
+ return signature(types.intp, val), codegen
+ elif isinstance(val, types.ListTypeIteratorType):
+ def codegen(context, builder, sig, args):
+ (value,) = args
+ intp_t = context.get_value_type(types.intp)
+ from numba.typed.listobject import ListIterInstance
+ iterobj = ListIterInstance(context, builder, sig.args[0], value)
+ return impl_ret_untracked(context, builder, intp_t, iterobj.size)
+ return signature(types.intp, val), codegen
+ else:
+ msg = ('Unsupported iterator found in array comprehension, try '
+ 'preallocating the array and filling manually.')
+ raise errors.TypingError(msg)
+
+
+def _inline_arraycall(func_ir, cfg, visited, loop, swapped, enable_prange=False,
+ typed=False):
+ """Look for array(list) call in the exit block of a given loop, and turn
+ list operations into array operations in the loop if the following
+ conditions are met:
+ 1. The exit block contains an array call on the list;
+ 2. The list variable is no longer live after array call;
+ 3. The list is created in the loop entry block;
+ 4. The loop is created from an range iterator whose length is known prior
+ to the loop;
+ 5. There is only one list_append operation on the list variable in the
+ loop body;
+ 6. The block that contains list_append dominates the loop head, which
+ ensures list length is the same as loop length;
+ If any condition check fails, no modification will be made to the incoming
+ IR.
+ """
+ debug_print = _make_debug_print("inline_arraycall")
+ # There should only be one loop exit
+ require(len(loop.exits) == 1)
+ exit_block = next(iter(loop.exits))
+ list_var, array_call_index, array_kws = _find_arraycall(
+ func_ir, func_ir.blocks[exit_block],
+ )
+
+ # check if dtype is present in array call
+ dtype_def = None
+ dtype_mod_def = None
+ if 'dtype' in array_kws:
+ require(isinstance(array_kws['dtype'], ir.Var))
+ # We require that dtype argument to be a constant of getattr Expr, and
+ # we'll remember its definition for later use.
+ dtype_def = get_definition(func_ir, array_kws['dtype'])
+ require(isinstance(dtype_def, ir.Expr) and dtype_def.op == 'getattr')
+ dtype_mod_def = get_definition(func_ir, dtype_def.value)
+
+ list_var_def = get_definition(func_ir, list_var)
+ debug_print("list_var = ", list_var, " def = ", list_var_def)
+ if isinstance(list_var_def, ir.Expr) and list_var_def.op == 'cast':
+ list_var_def = get_definition(func_ir, list_var_def.value)
+ # Check if the definition is a build_list
+ require(isinstance(list_var_def, ir.Expr) and
+ list_var_def.op == 'build_list')
+ # The build_list must be empty
+ require(len(list_var_def.items) == 0)
+
+ # Look for list_append in "last" block in loop body, which should be a block
+ # that is a post-dominator of the loop header.
+ list_append_stmts = []
+ for label in loop.body:
+ # We have to consider blocks of this loop, but not sub-loops.
+ # To achieve this, we require the set of "in_loops" of "label" to be
+ # visited loops.
+ in_visited_loops = [l.header in visited for l in cfg.in_loops(label)]
+ if not all(in_visited_loops):
+ continue
+ block = func_ir.blocks[label]
+ debug_print("check loop body block ", label)
+ for stmt in block.find_insts(ir.Assign):
+ expr = stmt.value
+ if isinstance(expr, ir.Expr) and expr.op == 'call':
+ func_def = get_definition(func_ir, expr.func)
+ if (isinstance(func_def, ir.Expr) and func_def.op == 'getattr'
+ and func_def.attr == 'append'):
+ list_def = get_definition(func_ir, func_def.value)
+ debug_print("list_def = ", list_def,
+ list_def is list_var_def)
+ if list_def is list_var_def:
+ # found matching append call
+ list_append_stmts.append((label, block, stmt))
+
+ # Require only one list_append, otherwise we won't know the indices
+ require(len(list_append_stmts) == 1)
+ append_block_label, append_block, append_stmt = list_append_stmts[0]
+
+ # Check if append_block (besides loop entry) dominates loop header.
+ # Since CFG doesn't give us this info without loop entry, we approximate
+ # by checking if the predecessor set of the header block is the same
+ # as loop_entries plus append_block, which is certainly more restrictive
+ # than necessary, and can be relaxed if needed.
+ preds = set(l for l, b in cfg.predecessors(loop.header))
+ debug_print("preds = ", preds, (loop.entries | set([append_block_label])))
+ require(preds == (loop.entries | set([append_block_label])))
+
+ # Find iterator in loop header
+ iter_vars = []
+ iter_first_vars = []
+ loop_header = func_ir.blocks[loop.header]
+ for stmt in loop_header.find_insts(ir.Assign):
+ expr = stmt.value
+ if isinstance(expr, ir.Expr):
+ if expr.op == 'iternext':
+ iter_def = get_definition(func_ir, expr.value)
+ debug_print("iter_def = ", iter_def)
+ iter_vars.append(expr.value)
+ elif expr.op == 'pair_first':
+ iter_first_vars.append(stmt.target)
+
+ # Require only one iterator in loop header
+ require(len(iter_vars) == 1 and len(iter_first_vars) == 1)
+ # variable that holds the iterator object
+ iter_var = iter_vars[0]
+ # variable that holds the value out of iterator
+ iter_first_var = iter_first_vars[0]
+
+ # Final requirement: only one loop entry, and we're going to modify it by:
+ # 1. replacing the list definition with an array definition;
+ # 2. adding a counter for the array iteration.
+ require(len(loop.entries) == 1)
+ loop_entry = func_ir.blocks[next(iter(loop.entries))]
+ terminator = loop_entry.terminator
+ scope = loop_entry.scope
+ loc = loop_entry.loc
+ stmts = []
+ removed = []
+
+ def is_removed(val, removed):
+ if isinstance(val, ir.Var):
+ for x in removed:
+ if x.name == val.name:
+ return True
+ return False
+
+ # Skip list construction and skip terminator, add the rest to stmts
+ for i in range(len(loop_entry.body) - 1):
+ stmt = loop_entry.body[i]
+ if (isinstance(stmt, ir.Assign) and
+ (stmt.value is list_def or is_removed(stmt.value, removed))):
+ removed.append(stmt.target)
+ else:
+ stmts.append(stmt)
+ debug_print("removed variables: ", removed)
+
+ # Define an index_var to index the array.
+ # If the range happens to be single step ranges like range(n), or
+ # range(m, n), then the index_var correlates to iterator index; otherwise
+ # we'll have to define a new counter.
+ range_def = guard(_find_iter_range, func_ir, iter_var, swapped)
+ index_var = scope.redefine("index", loc)
+ if range_def and range_def[0] == 0:
+ # iterator starts with 0, index_var can just be iter_first_var
+ index_var = iter_first_var
+ else:
+ # index_var = -1 # starting the index with -1 since it will incremented
+ # in loop header
+ stmts.append(_new_definition(func_ir, index_var,
+ ir.Const(value=-1, loc=loc), loc))
+
+ # Insert statement to get the size of the loop iterator
+ size_var = scope.redefine("size", loc)
+ if range_def:
+ start, stop, range_func_def = range_def
+ if start == 0:
+ size_val = stop
+ else:
+ size_val = ir.Expr.binop(fn=operator.sub, lhs=stop, rhs=start,
+ loc=loc)
+ # we can parallelize this loop if enable_prange = True, by changing
+ # range function from range, to prange.
+ if enable_prange and isinstance(range_func_def, ir.Global):
+ range_func_def.name = 'internal_prange'
+ range_func_def.value = internal_prange
+
+ else:
+ # this doesn't work in objmode as it's effectively untyped
+ if typed:
+ len_func_var = scope.redefine("len_func", loc)
+ stmts.append(_new_definition(func_ir, len_func_var,
+ ir.Global('length_of_iterator',
+ length_of_iterator,
+ loc=loc),
+ loc))
+ size_val = ir.Expr.call(len_func_var, (iter_var,), (), loc=loc)
+ else:
+ raise GuardException
+
+ stmts.append(_new_definition(func_ir, size_var, size_val, loc))
+
+ size_tuple_var = scope.redefine("size_tuple", loc)
+ stmts.append(_new_definition(func_ir, size_tuple_var,
+ ir.Expr.build_tuple(items=[size_var], loc=loc), loc))
+
+ # Insert array allocation
+ array_var = scope.redefine("array", loc)
+ empty_func = scope.redefine("empty_func", loc)
+ if dtype_def and dtype_mod_def:
+ # when dtype is present, we'll call empty with dtype
+ dtype_mod_var = scope.redefine("dtype_mod", loc)
+ dtype_var = scope.redefine("dtype", loc)
+ stmts.append(_new_definition(
+ func_ir, dtype_mod_var, dtype_mod_def, loc))
+ stmts.append(_new_definition(
+ func_ir, dtype_var,
+ ir.Expr.getattr(dtype_mod_var, dtype_def.attr, loc), loc))
+ stmts.append(_new_definition(
+ func_ir, empty_func, ir.Global('empty', np.empty, loc=loc), loc))
+ array_kws = [('dtype', dtype_var)]
+ else:
+ # this doesn't work in objmode as it's effectively untyped
+ if typed:
+ # otherwise we'll call unsafe_empty_inferred
+ stmts.append(_new_definition(
+ func_ir, empty_func,
+ ir.Global('unsafe_empty_inferred', unsafe_empty_inferred,
+ loc=loc),
+ loc))
+ array_kws = []
+ else:
+ raise GuardException
+
+ # array_var = empty_func(size_tuple_var)
+ stmts.append(_new_definition(func_ir, array_var,
+ ir.Expr.call(empty_func, (size_tuple_var,), list(array_kws),
+ loc=loc), loc))
+
+ # Add back removed just in case they are used by something else
+ for var in removed:
+ stmts.append(_new_definition(func_ir, var, array_var, loc))
+
+ # Add back terminator
+ stmts.append(terminator)
+ # Modify loop_entry
+ loop_entry.body = stmts
+
+ if range_def:
+ if range_def[0] != 0:
+ # when range doesn't start from 0, index_var becomes loop index
+ # (iter_first_var) minus an offset (range_def[0])
+ terminator = loop_header.terminator
+ assert (isinstance(terminator, ir.Branch))
+ # find the block in the loop body that header jumps to
+ block_id = terminator.truebr
+ blk = func_ir.blocks[block_id]
+ loc = blk.loc
+ blk.body.insert(
+ 0,
+ _new_definition(
+ func_ir, index_var,
+ ir.Expr.binop(fn=operator.sub, lhs=iter_first_var,
+ rhs=range_def[0], loc=loc),
+ loc
+ )
+ )
+ else:
+ # Insert index_var increment to the end of loop header
+ loc = loop_header.loc
+ terminator = loop_header.terminator
+ stmts = loop_header.body[0:-1]
+ next_index_var = scope.redefine("next_index", loc)
+ one = scope.redefine("one", loc)
+ # one = 1
+ stmts.append(_new_definition(func_ir, one,
+ ir.Const(value=1,loc=loc), loc))
+ # next_index_var = index_var + 1
+ stmts.append(_new_definition(func_ir, next_index_var,
+ ir.Expr.binop(fn=operator.add, lhs=index_var, rhs=one,
+ loc=loc), loc))
+ # index_var = next_index_var
+ stmts.append(_new_definition(func_ir, index_var, next_index_var, loc))
+ stmts.append(terminator)
+ loop_header.body = stmts
+
+ # In append_block, change list_append into array assign
+ for i in range(len(append_block.body)):
+ if append_block.body[i] is append_stmt:
+ debug_print("Replace append with SetItem")
+ append_block.body[i] = ir.SetItem(
+ target=array_var, index=index_var,
+ value=append_stmt.value.args[0], loc=append_stmt.loc)
+
+ # replace array call, by changing "a = array(b)" to "a = b"
+ stmt = func_ir.blocks[exit_block].body[array_call_index]
+ # stmt can be either array call or SetItem, we only replace array call
+ if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Expr):
+ stmt.value = array_var
+ func_ir._definitions[stmt.target.name] = [stmt.value]
+
+ return True
+
+
+def _find_unsafe_empty_inferred(func_ir, expr):
+ unsafe_empty_inferred
+ require(isinstance(expr, ir.Expr) and expr.op == 'call')
+ callee = expr.func
+ callee_def = get_definition(func_ir, callee)
+ require(isinstance(callee_def, ir.Global))
+ _make_debug_print("_find_unsafe_empty_inferred")(callee_def.value)
+ return callee_def.value == unsafe_empty_inferred
+
+
+def _fix_nested_array(func_ir):
+ """Look for assignment like: a[..] = b, where both a and b are numpy arrays,
+ and try to eliminate array b by expanding a with an extra dimension.
+ """
+ blocks = func_ir.blocks
+ cfg = compute_cfg_from_blocks(blocks)
+ usedefs = compute_use_defs(blocks)
+ empty_deadmap = dict([(label, set()) for label in blocks.keys()])
+ livemap = compute_live_variables(cfg, blocks, usedefs.defmap, empty_deadmap)
+
+ def find_array_def(arr):
+ """Find numpy array definition such as
+ arr = numba.unsafe.ndarray.empty_inferred(...).
+ If it is arr = b[...], find array definition of b recursively.
+ """
+ arr_def = get_definition(func_ir, arr)
+ _make_debug_print("find_array_def")(arr, arr_def)
+ if isinstance(arr_def, ir.Expr):
+ if guard(_find_unsafe_empty_inferred, func_ir, arr_def):
+ return arr_def
+ elif arr_def.op == 'getitem':
+ return find_array_def(arr_def.value)
+ raise GuardException
+
+ def fix_dependencies(expr, varlist):
+ """Double check if all variables in varlist are defined before
+ expr is used. Try to move constant definition when the check fails.
+ Bails out by raising GuardException if it can't be moved.
+ """
+ debug_print = _make_debug_print("fix_dependencies")
+ for label, block in blocks.items():
+ scope = block.scope
+ body = block.body
+ defined = set()
+ for i in range(len(body)):
+ inst = body[i]
+ if isinstance(inst, ir.Assign):
+ defined.add(inst.target.name)
+ if inst.value is expr:
+ new_varlist = []
+ for var in varlist:
+ # var must be defined before this inst, or live
+ # and not later defined.
+ if (var.name in defined or
+ (var.name in livemap[label] and
+ not (var.name in usedefs.defmap[label]))):
+ debug_print(var.name, " already defined")
+ new_varlist.append(var)
+ else:
+ debug_print(var.name, " not yet defined")
+ var_def = get_definition(func_ir, var.name)
+ if isinstance(var_def, ir.Const):
+ loc = var.loc
+ new_var = scope.redefine("new_var", loc)
+ new_const = ir.Const(var_def.value, loc)
+ new_vardef = _new_definition(
+ func_ir, new_var, new_const, loc)
+ new_body = []
+ new_body.extend(body[:i])
+ new_body.append(new_vardef)
+ new_body.extend(body[i:])
+ block.body = new_body
+ new_varlist.append(new_var)
+ else:
+ raise GuardException
+ return new_varlist
+ # when expr is not found in block
+ raise GuardException
+
+ def fix_array_assign(stmt):
+ """For assignment like lhs[idx] = rhs, where both lhs and rhs are
+ arrays, do the following:
+ 1. find the definition of rhs, which has to be a call to
+ numba.unsafe.ndarray.empty_inferred
+ 2. find the source array creation for lhs, insert an extra dimension of
+ size of b.
+ 3. replace the definition of
+ rhs = numba.unsafe.ndarray.empty_inferred(...) with rhs = lhs[idx]
+ """
+ require(isinstance(stmt, ir.SetItem))
+ require(isinstance(stmt.value, ir.Var))
+ debug_print = _make_debug_print("fix_array_assign")
+ debug_print("found SetItem: ", stmt)
+ lhs = stmt.target
+ # Find the source array creation of lhs
+ lhs_def = find_array_def(lhs)
+ debug_print("found lhs_def: ", lhs_def)
+ rhs_def = get_definition(func_ir, stmt.value)
+ debug_print("found rhs_def: ", rhs_def)
+ require(isinstance(rhs_def, ir.Expr))
+ if rhs_def.op == 'cast':
+ rhs_def = get_definition(func_ir, rhs_def.value)
+ require(isinstance(rhs_def, ir.Expr))
+ require(_find_unsafe_empty_inferred(func_ir, rhs_def))
+ # Find the array dimension of rhs
+ dim_def = get_definition(func_ir, rhs_def.args[0])
+ require(isinstance(dim_def, ir.Expr) and dim_def.op == 'build_tuple')
+ debug_print("dim_def = ", dim_def)
+ extra_dims = [get_definition(func_ir, x, lhs_only=True)
+ for x in dim_def.items ]
+ debug_print("extra_dims = ", extra_dims)
+ # Expand size tuple when creating lhs_def with extra_dims
+ size_tuple_def = get_definition(func_ir, lhs_def.args[0])
+ require(isinstance(size_tuple_def, ir.Expr) and
+ size_tuple_def.op == 'build_tuple')
+ debug_print("size_tuple_def = ", size_tuple_def)
+ extra_dims = fix_dependencies(size_tuple_def, extra_dims)
+ size_tuple_def.items += extra_dims
+ # In-place modify rhs_def to be getitem
+ rhs_def.op = 'getitem'
+ rhs_def.fn = operator.getitem
+ rhs_def.value = get_definition(func_ir, lhs, lhs_only=True)
+ rhs_def.index = stmt.index
+ del rhs_def._kws['func']
+ del rhs_def._kws['args']
+ del rhs_def._kws['vararg']
+ del rhs_def._kws['kws']
+ # success
+ return True
+
+ for label in find_topo_order(func_ir.blocks):
+ block = func_ir.blocks[label]
+ for stmt in block.body:
+ if guard(fix_array_assign, stmt):
+ block.body.remove(stmt)
+
+
+def _new_definition(func_ir, var, value, loc):
+ func_ir._definitions[var.name] = [value]
+ return ir.Assign(value=value, target=var, loc=loc)
+
+
+@rewrites.register_rewrite('after-inference')
+class RewriteArrayOfConsts(rewrites.Rewrite):
+ '''The RewriteArrayOfConsts class is responsible for finding
+ 1D array creations from a constant list, and rewriting it into
+ direct initialization of array elements without creating the list.
+ '''
+ def __init__(self, state, *args, **kws):
+ self.typingctx = state.typingctx
+ super(RewriteArrayOfConsts, self).__init__(*args, **kws)
+
+ def match(self, func_ir, block, typemap, calltypes):
+ if len(calltypes) == 0:
+ return False
+ self.crnt_block = block
+ self.new_body = guard(_inline_const_arraycall, block, func_ir,
+ self.typingctx, typemap, calltypes)
+ return self.new_body is not None
+
+ def apply(self):
+ self.crnt_block.body = self.new_body
+ return self.crnt_block
+
+
+def _inline_const_arraycall(block, func_ir, context, typemap, calltypes):
+ """Look for array(list) call where list is a constant list created by
+ build_list, and turn them into direct array creation and initialization, if
+ the following conditions are met:
+ 1. The build_list call immediate precedes the array call;
+ 2. The list variable is no longer live after array call;
+ If any condition check fails, no modification will be made.
+ """
+ debug_print = _make_debug_print("inline_const_arraycall")
+ scope = block.scope
+
+ def inline_array(array_var, expr, stmts, list_vars, dels):
+ """Check to see if the given "array_var" is created from a list
+ of constants, and try to inline the list definition as array
+ initialization.
+
+ Extra statements produced with be appended to "stmts".
+ """
+ callname = guard(find_callname, func_ir, expr)
+ require(callname and callname[1] == 'numpy' and callname[0] == 'array')
+ require(expr.args[0].name in list_vars)
+ ret_type = calltypes[expr].return_type
+ require(isinstance(ret_type, types.ArrayCompatible) and
+ ret_type.ndim == 1)
+ loc = expr.loc
+ list_var = expr.args[0]
+ # Get the type of the array to be created.
+ array_typ = typemap[array_var.name]
+ debug_print("inline array_var = ", array_var, " list_var = ", list_var)
+ # Get the element type of the array to be created.
+ dtype = array_typ.dtype
+ # Get the sequence of operations to provide values to the new array.
+ seq, _ = find_build_sequence(func_ir, list_var)
+ size = len(seq)
+ # Create a tuple to pass to empty below to specify the new array size.
+ size_var = scope.redefine("size", loc)
+ size_tuple_var = scope.redefine("size_tuple", loc)
+ size_typ = types.intp
+ size_tuple_typ = types.UniTuple(size_typ, 1)
+ typemap[size_var.name] = size_typ
+ typemap[size_tuple_var.name] = size_tuple_typ
+ stmts.append(
+ _new_definition(func_ir, size_var,
+ ir.Const(size, loc=loc), loc))
+ stmts.append(
+ _new_definition(func_ir, size_tuple_var,
+ ir.Expr.build_tuple(items=[size_var], loc=loc),
+ loc))
+
+ # The general approach is to create an empty array and then fill
+ # the elements in one-by-one from their specification.
+
+ # Get the numpy type to pass to empty.
+ nptype = types.DType(dtype)
+
+ # Create a variable to hold the numpy empty function.
+ empty_func = scope.redefine("empty_func", loc)
+ fnty = get_np_ufunc_typ(np.empty)
+ context.resolve_function_type(fnty, (size_typ,), {'dtype': nptype})
+
+ typemap[empty_func.name] = fnty
+
+ stmts.append(
+ _new_definition(func_ir, empty_func,
+ ir.Global('empty', np.empty, loc=loc), loc))
+
+ # We pass two arguments to empty, first the size tuple and second
+ # the dtype of the new array. Here, we created typ_var which is
+ # the dtype argument of the new array. typ_var in turn is created
+ # by getattr of the dtype string on the numpy module.
+
+ # Create var for numpy module.
+ g_np_var = scope.redefine("$np_g_var", loc)
+ typemap[g_np_var.name] = types.misc.Module(np)
+ g_np = ir.Global('np', np, loc)
+ stmts.append(_new_definition(func_ir, g_np_var, g_np, loc))
+
+ # Create var for result of numpy..
+ typ_var = scope.redefine("$np_typ_var", loc)
+ typemap[typ_var.name] = nptype
+ dtype_str = str(dtype)
+ if dtype_str == 'bool':
+ dtype_str = 'bool_'
+ # Get dtype attribute of numpy module.
+ np_typ_getattr = ir.Expr.getattr(g_np_var, dtype_str, loc)
+ stmts.append(_new_definition(func_ir, typ_var, np_typ_getattr, loc))
+
+ # Create the call to numpy.empty passing the size tuple and dtype var.
+ empty_call = ir.Expr.call(empty_func, [size_var, typ_var], {}, loc=loc)
+ calltypes[empty_call] = typing.signature(array_typ, size_typ, nptype)
+ stmts.append(_new_definition(func_ir, array_var, empty_call, loc))
+
+ # Fill in the new empty array one-by-one.
+ for i in range(size):
+ index_var = scope.redefine("index", loc)
+ index_typ = types.intp
+ typemap[index_var.name] = index_typ
+ stmts.append(
+ _new_definition(func_ir, index_var, ir.Const(i, loc), loc))
+ setitem = ir.SetItem(array_var, index_var, seq[i], loc)
+ calltypes[setitem] = typing.signature(types.none, array_typ,
+ index_typ, dtype)
+ stmts.append(setitem)
+
+ stmts.extend(dels)
+ return True
+
+ class State(object):
+ """
+ This class is used to hold the state in the following loop so as to make
+ it easy to reset the state of the variables tracking the various
+ statement kinds
+ """
+
+ def __init__(self):
+ # list_vars keep track of the variable created from the latest
+ # build_list instruction, as well as its synonyms.
+ self.list_vars = []
+ # dead_vars keep track of those in list_vars that are considered
+ # dead.
+ self.dead_vars = []
+ # list_items keep track of the elements used in build_list.
+ self.list_items = []
+ self.stmts = []
+ # dels keep track of the deletion of list_items, which will need to
+ # be moved after array initialization.
+ self.dels = []
+ # tracks if a modification has taken place
+ self.modified = False
+
+ def reset(self):
+ """
+ Resets the internal state of the variables used for tracking
+ """
+ self.list_vars = []
+ self.dead_vars = []
+ self.list_items = []
+ self.dels = []
+
+ def list_var_used(self, inst):
+ """
+ Returns True if the list being analysed is used between the
+ build_list and the array call.
+ """
+ return any([x.name in self.list_vars for x in inst.list_vars()])
+
+ state = State()
+
+ for inst in block.body:
+ if isinstance(inst, ir.Assign):
+ if isinstance(inst.value, ir.Var):
+ if inst.value.name in state.list_vars:
+ state.list_vars.append(inst.target.name)
+ state.stmts.append(inst)
+ continue
+ elif isinstance(inst.value, ir.Expr):
+ expr = inst.value
+ if expr.op == 'build_list':
+ # new build_list encountered, reset state
+ state.reset()
+ state.list_items = [x.name for x in expr.items]
+ state.list_vars = [inst.target.name]
+ state.stmts.append(inst)
+ continue
+ elif expr.op == 'call' and expr in calltypes:
+ if guard(inline_array, inst.target, expr,
+ state.stmts, state.list_vars, state.dels):
+ state.modified = True
+ continue
+ elif isinstance(inst, ir.Del):
+ removed_var = inst.value
+ if removed_var in state.list_items:
+ state.dels.append(inst)
+ continue
+ elif removed_var in state.list_vars:
+ # one of the list_vars is considered dead.
+ state.dead_vars.append(removed_var)
+ state.list_vars.remove(removed_var)
+ state.stmts.append(inst)
+ if state.list_vars == []:
+ # if all list_vars are considered dead, we need to filter
+ # them out from existing stmts to completely remove
+ # build_list.
+ # Note that if a translation didn't take place, dead_vars
+ # will also be empty when we reach this point.
+ body = []
+ for inst in state.stmts:
+ if ((isinstance(inst, ir.Assign) and
+ inst.target.name in state.dead_vars) or
+ (isinstance(inst, ir.Del) and
+ inst.value in state.dead_vars)):
+ continue
+ body.append(inst)
+ state.stmts = body
+ state.dead_vars = []
+ state.modified = True
+ continue
+ state.stmts.append(inst)
+
+ # If the list is used in any capacity between build_list and array
+ # call, then we must call off the translation for this list because
+ # it could be mutated and list_items would no longer be applicable.
+ if state.list_var_used(inst):
+ state.reset()
+
+ return state.stmts if state.modified else None
diff --git a/venv/lib/python3.10/site-packages/numba/core/interpreter.py b/venv/lib/python3.10/site-packages/numba/core/interpreter.py
new file mode 100644
index 0000000000000000000000000000000000000000..605ca2982999cf3f813b5b39dbd6119a8db872de
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/interpreter.py
@@ -0,0 +1,3424 @@
+import builtins
+import collections
+import dis
+import operator
+import logging
+import textwrap
+
+from numba.core import errors, ir, config
+from numba.core.errors import (
+ NotDefinedError,
+ UnsupportedBytecodeError,
+ error_extras,
+)
+from numba.core.ir_utils import get_definition, guard
+from numba.core.utils import (PYVERSION, BINOPS_TO_OPERATORS,
+ INPLACE_BINOPS_TO_OPERATORS,)
+from numba.core.byteflow import Flow, AdaptDFA, AdaptCFA, BlockKind
+from numba.core.unsafe import eh
+from numba.cpython.unsafe.tuple import unpack_single_tuple
+
+
+if PYVERSION in ((3, 12), (3, 13)):
+ # Operands for CALL_INTRINSIC_1
+ from numba.core.byteflow import CALL_INTRINSIC_1_Operand as ci1op
+elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+else:
+ raise NotImplementedError(PYVERSION)
+
+
+class _UNKNOWN_VALUE(object):
+ """Represents an unknown value, this is for ease of debugging purposes only.
+ """
+
+ def __init__(self, varname):
+ self._varname = varname
+
+ def __repr__(self):
+ return "_UNKNOWN_VALUE({})".format(self._varname)
+
+
+_logger = logging.getLogger(__name__)
+
+
+class Assigner(object):
+ """
+ This object keeps track of potential assignment simplifications
+ inside a code block.
+ For example `$O.1 = x` followed by `y = $0.1` can be simplified
+ into `y = x`, but it's not possible anymore if we have `x = z`
+ in-between those two instructions.
+
+ NOTE: this is not only an optimization, but is actually necessary
+ due to certain limitations of Numba - such as only accepting the
+ returning of an array passed as function argument.
+ """
+
+ def __init__(self):
+ # { destination variable name -> source Var object }
+ self.dest_to_src = {}
+ # Basically a reverse mapping of dest_to_src:
+ # { source variable name -> all destination names in dest_to_src }
+ self.src_invalidate = collections.defaultdict(list)
+ self.unused_dests = set()
+
+ def assign(self, srcvar, destvar):
+ """
+ Assign *srcvar* to *destvar*. Return either *srcvar* or a possible
+ simplified assignment source (earlier assigned to *srcvar*).
+ """
+ srcname = srcvar.name
+ destname = destvar.name
+ if destname in self.src_invalidate:
+ # destvar will change, invalidate all previously known
+ # simplifications
+ for d in self.src_invalidate.pop(destname):
+ self.dest_to_src.pop(d)
+ if srcname in self.dest_to_src:
+ srcvar = self.dest_to_src[srcname]
+ if destvar.is_temp:
+ self.dest_to_src[destname] = srcvar
+ self.src_invalidate[srcname].append(destname)
+ self.unused_dests.add(destname)
+ return srcvar
+
+ def get_assignment_source(self, destname):
+ """
+ Get a possible assignment source (a ir.Var instance) to replace
+ *destname*, otherwise None.
+ """
+ if destname in self.dest_to_src:
+ return self.dest_to_src[destname]
+ self.unused_dests.discard(destname)
+ return None
+
+
+def _remove_assignment_definition(old_body, idx, func_ir, already_deleted_defs):
+ """
+ Deletes the definition defined for old_body at index idx
+ from func_ir. We assume this stmt will be deleted from
+ new_body.
+
+ In some optimizations we may update the same variable multiple times.
+ In this situation, we only need to delete a particular definition once,
+ this is tracked in already_deleted_def, which is a map from
+ assignment name to the set of values that have already been
+ deleted.
+ """
+ lhs = old_body[idx].target.name
+ rhs = old_body[idx].value
+ if rhs in func_ir._definitions[lhs]:
+ func_ir._definitions[lhs].remove(rhs)
+ already_deleted_defs[lhs].add(rhs)
+ elif rhs not in already_deleted_defs[lhs]:
+ raise UnsupportedBytecodeError(
+ "Inconsistency found in the definitions while executing"
+ " a peephole optimization. This suggests an internal"
+ " error or inconsistency elsewhere in the compiler."
+ )
+
+
+def _call_function_ex_replace_kws_small(
+ old_body,
+ keyword_expr,
+ new_body,
+ buildmap_idx,
+ func_ir,
+ already_deleted_defs
+):
+ """
+ Extracts the kws args passed as varkwarg
+ for CALL_FUNCTION_EX. This pass is taken when
+ n_kws <= 15 and the bytecode looks like:
+
+ # Start for each argument
+ LOAD_FAST # Load each argument.
+ # End for each argument
+ ...
+ BUILD_CONST_KEY_MAP # Build a map
+
+ In the generated IR, the varkwarg refers
+ to a single build_map that contains all of the
+ kws. In addition to returning the kws, this
+ function updates new_body to remove all usage
+ of the map.
+ """
+ kws = keyword_expr.items.copy()
+ # kws are required to have constant keys.
+ # We update these with the value_indexes
+ value_indexes = keyword_expr.value_indexes
+ for key, index in value_indexes.items():
+ kws[index] = (key, kws[index][1])
+ # Remove the build_map by setting the list
+ # index to None. Nones will be removed later.
+ new_body[buildmap_idx] = None
+ # Remove the definition.
+ _remove_assignment_definition(
+ old_body, buildmap_idx, func_ir, already_deleted_defs
+ )
+ return kws
+
+
+def _call_function_ex_replace_kws_large(
+ old_body,
+ buildmap_name,
+ buildmap_idx,
+ search_end,
+ new_body,
+ func_ir,
+ errmsg,
+ already_deleted_defs
+):
+ """
+ Extracts the kws args passed as varkwarg
+ for CALL_FUNCTION_EX. This pass is taken when
+ n_kws > 15 and the bytecode looks like:
+
+ BUILD_MAP # Construct the map
+ # Start for each argument
+ LOAD_CONST # Load a constant for the name of the argument
+ LOAD_FAST # Load each argument.
+ MAP_ADD # Append the (key, value) pair to the map
+ # End for each argument
+
+ In the IR generated, the initial build map is empty and a series
+ of setitems are applied afterwards. THE IR looks like:
+
+ $build_map_var = build_map(items=[])
+ $constvar = const(str, ...) # create the const key
+ # CREATE THE ARGUMENT, This may take multiple lines.
+ $created_arg = ...
+ $var = getattr(
+ value=$build_map_var,
+ attr=__setitem__,
+ )
+ $unused_var = call $var($constvar, $created_arg)
+
+ We iterate through the IR, deleting all usages of the buildmap
+ from the new_body, and adds the kws to a new kws list.
+ """
+ # Remove the build_map from the body.
+ new_body[buildmap_idx] = None
+ # Remove the definition.
+ _remove_assignment_definition(
+ old_body, buildmap_idx, func_ir, already_deleted_defs
+ )
+ kws = []
+ search_start = buildmap_idx + 1
+ while search_start <= search_end:
+ # The first value must be a constant.
+ const_stmt = old_body[search_start]
+ if not (
+ isinstance(const_stmt, ir.Assign)
+ and isinstance(const_stmt.value, ir.Const)
+ ):
+ # We cannot handle this format so raise the
+ # original error message.
+ raise UnsupportedBytecodeError(errmsg)
+ key_var_name = const_stmt.target.name
+ key_val = const_stmt.value.value
+ search_start += 1
+ # Now we need to search for a getattr with setitem
+ found_getattr = False
+ while (
+ search_start <= search_end
+ and not found_getattr
+ ):
+ getattr_stmt = old_body[search_start]
+ if (
+ isinstance(getattr_stmt, ir.Assign)
+ and isinstance(getattr_stmt.value, ir.Expr)
+ and getattr_stmt.value.op == "getattr"
+ and (
+ getattr_stmt.value.value.name
+ == buildmap_name
+ )
+ and getattr_stmt.value.attr == "__setitem__"
+ ):
+ found_getattr = True
+ else:
+ # If the argument is "created" in JIT, then there
+ # will be intermediate operations in between setitems.
+ # For example we have arg5=pow(arg5, 2),
+ # then the IR would look like:
+ #
+ # # Creation of the constant key.
+ # $const44.26 = const(str, arg5)
+ #
+ # # Argument creation. This is the section we are skipping
+ # $46load_global.27 = global(pow: )
+ # $const50.29 = const(int, 2)
+ # $call.30 = call $46load_global.27(arg5, $const50.29)
+ #
+ # # Setitem with arg5
+ # $54map_add.31 = getattr(value=$map.2, attr=__setitem__)
+ # $54map_add.32 = call $54map_add.31($const44.26, $call.30)
+ search_start += 1
+ if (
+ not found_getattr
+ or search_start == search_end
+ ):
+ # We cannot handle this format so raise the
+ # original error message.
+ raise UnsupportedBytecodeError(errmsg)
+ setitem_stmt = old_body[search_start + 1]
+ if not (
+ isinstance(setitem_stmt, ir.Assign)
+ and isinstance(setitem_stmt.value, ir.Expr)
+ and setitem_stmt.value.op == "call"
+ and (
+ setitem_stmt.value.func.name
+ == getattr_stmt.target.name
+ )
+ and len(setitem_stmt.value.args) == 2
+ and (
+ setitem_stmt.value.args[0].name
+ == key_var_name
+ )
+ ):
+ # A call statement should always immediately follow the
+ # getattr. If for some reason this doesn't match the code
+ # format, we raise the original error message. This check
+ # is meant as a precaution.
+ raise UnsupportedBytecodeError(errmsg)
+ arg_var = setitem_stmt.value.args[1]
+ # Append the (key, value) pair.
+ kws.append((key_val, arg_var))
+ # Remove the __setitem__ getattr and call
+ new_body[search_start] = None
+ new_body[search_start + 1] = None
+ # Remove the definitions.
+ _remove_assignment_definition(
+ old_body, search_start, func_ir, already_deleted_defs
+ )
+ _remove_assignment_definition(
+ old_body, search_start + 1, func_ir, already_deleted_defs
+ )
+ search_start += 2
+ return kws
+
+
+def _call_function_ex_replace_args_small(
+ old_body,
+ tuple_expr,
+ new_body,
+ buildtuple_idx,
+ func_ir,
+ already_deleted_defs
+):
+ """
+ Extracts the args passed as vararg
+ for CALL_FUNCTION_EX. This pass is taken when
+ n_args <= 30 and the bytecode looks like:
+
+ # Start for each argument
+ LOAD_FAST # Load each argument.
+ # End for each argument
+ ...
+ BUILD_TUPLE # Create a tuple of the arguments
+
+ In the IR generated, the vararg refer
+ to a single build_tuple that contains all of the
+ args. In addition to returning the args, this
+ function updates new_body to remove all usage
+ of the tuple.
+ """
+ # Delete the build tuple
+ new_body[buildtuple_idx] = None
+ # Remove the definition.
+ _remove_assignment_definition(
+ old_body, buildtuple_idx, func_ir, already_deleted_defs
+ )
+ # Return the args.
+ return tuple_expr.items
+
+
+def _call_function_ex_replace_args_large(
+ old_body,
+ vararg_stmt,
+ new_body,
+ search_end,
+ func_ir,
+ errmsg,
+ already_deleted_defs
+):
+ """
+ Extracts the args passed as vararg
+ for CALL_FUNCTION_EX. This pass is taken when
+ n_args > 30 and the bytecode looks like:
+
+ BUILD_TUPLE # Create a list to append to
+ # Start for each argument
+ LOAD_FAST # Load each argument.
+ LIST_APPEND # Add the argument to the list
+ # End for each argument
+ ...
+ LIST_TO_TUPLE # Convert the args to a tuple.
+
+ In the IR generated, the tuple is created by concatenating
+ together several 1 element tuples to an initial empty tuple.
+ We traverse backwards in the IR, collecting args, until we
+ find the original empty tuple. For example, the IR might
+ look like:
+
+ $orig_tuple = build_tuple(items=[])
+ $first_var = build_tuple(items=[Var(arg0, test.py:6)])
+ $next_tuple = $orig_tuple + $first_var
+ ...
+ $final_var = build_tuple(items=[Var(argn, test.py:6)])
+ $final_tuple = $prev_tuple + $final_var
+ $varargs_var = $final_tuple
+ """
+ # We traverse to the front of the block to look for the original
+ # tuple.
+ search_start = 0
+ total_args = []
+ if (
+ isinstance(vararg_stmt, ir.Assign)
+ and isinstance(vararg_stmt.value, ir.Var)
+ ):
+ target_name = vararg_stmt.value.name
+ # If there is an initial assignment, delete it
+ new_body[search_end] = None
+ # Remove the definition.
+ _remove_assignment_definition(
+ old_body, search_end, func_ir, already_deleted_defs
+ )
+ search_end -= 1
+ else:
+ # There must always be an initial assignment
+ # https://github.com/numba/numba/blob/59fa2e335be68148b3bd72a29de3ff011430038d/numba/core/interpreter.py#L259-L260
+ # If this changes we may need to support this branch.
+ raise AssertionError("unreachable")
+ # Traverse backwards to find all concatenations
+ # until eventually reaching the original empty tuple.
+ while search_end >= search_start:
+ concat_stmt = old_body[search_end]
+ if (
+ isinstance(concat_stmt, ir.Assign)
+ and concat_stmt.target.name == target_name
+ and isinstance(concat_stmt.value, ir.Expr)
+ and concat_stmt.value.op == "build_tuple"
+ and not concat_stmt.value.items
+ ):
+ new_body[search_end] = None
+ # Remove the definition.
+ _remove_assignment_definition(
+ old_body, search_end, func_ir, already_deleted_defs
+ )
+ # If we have reached the build_tuple we exit.
+ break
+ else:
+ # We expect to find another arg to append.
+ # The first stmt must be a binop "add"
+ if (search_end == search_start) or not (
+ isinstance(concat_stmt, ir.Assign)
+ and (
+ concat_stmt.target.name
+ == target_name
+ )
+ and isinstance(
+ concat_stmt.value, ir.Expr
+ )
+ and concat_stmt.value.op == "binop"
+ and concat_stmt.value.fn == operator.add
+ ):
+ # We cannot handle this format.
+ raise UnsupportedBytecodeError(errmsg)
+ lhs_name = concat_stmt.value.lhs.name
+ rhs_name = concat_stmt.value.rhs.name
+ # The previous statement should be a
+ # build_tuple containing the arg.
+ arg_tuple_stmt = old_body[search_end - 1]
+ if not (
+ isinstance(arg_tuple_stmt, ir.Assign)
+ and isinstance(
+ arg_tuple_stmt.value, ir.Expr
+ )
+ and (
+ arg_tuple_stmt.value.op
+ == "build_tuple"
+ )
+ and len(arg_tuple_stmt.value.items) == 1
+ ):
+ # We cannot handle this format.
+ raise UnsupportedBytecodeError(errmsg)
+ if arg_tuple_stmt.target.name == lhs_name:
+ # The tuple should always be generated on the RHS.
+ raise AssertionError("unreachable")
+ elif arg_tuple_stmt.target.name == rhs_name:
+ target_name = lhs_name
+ else:
+ # We cannot handle this format.
+ raise UnsupportedBytecodeError(errmsg)
+ total_args.append(
+ arg_tuple_stmt.value.items[0]
+ )
+ new_body[search_end] = None
+ new_body[search_end - 1] = None
+ # Remove the definitions.
+ _remove_assignment_definition(
+ old_body, search_end, func_ir, already_deleted_defs
+ )
+ _remove_assignment_definition(
+ old_body, search_end - 1, func_ir, already_deleted_defs
+ )
+ search_end -= 2
+ # Avoid any space between appends
+ keep_looking = True
+ while search_end >= search_start and keep_looking:
+ next_stmt = old_body[search_end]
+ if (
+ isinstance(next_stmt, ir.Assign)
+ and (
+ next_stmt.target.name
+ == target_name
+ )
+ ):
+ keep_looking = False
+ else:
+ # If the argument is "created" in JIT, then there
+ # will be intermediate operations in between appends.
+ # For example if the next arg after arg4 is pow(arg5, 2),
+ # then the IR would look like:
+ #
+ # # Appending arg4
+ # $arg4_tup = build_tuple(items=[arg4])
+ # $append_var.5 = $append_var.4 + $arg4_tup
+ #
+ # # Creation of arg5.
+ # # This is the section that we are skipping.
+ # $32load_global.20 = global(pow: )
+ # $const36.22 = const(int, 2)
+ # $call.23 = call $32load_global.20(arg5, $const36.22)
+ #
+ # # Appending arg5
+ # $arg5_tup = build_tuple(items=[$call.23])
+ # $append_var.6 = $append_var.5 + $arg5_tup
+ search_end -= 1
+ if search_end == search_start:
+ # If we reached the start we never found the build_tuple.
+ # We cannot handle this format so raise the
+ # original error message.
+ raise UnsupportedBytecodeError(errmsg)
+ # Reverse the arguments so we get the correct order.
+ return total_args[::-1]
+
+
+def peep_hole_call_function_ex_to_call_function_kw(func_ir):
+ """
+ This peephole rewrites a bytecode sequence unique to Python 3.10
+ where CALL_FUNCTION_EX is used instead of CALL_FUNCTION_KW because of
+ stack limitations set by CPython. This limitation is imposed whenever
+ a function call has too many arguments or keyword arguments.
+
+ https://github.com/python/cpython/blob/a58ebcc701dd6c43630df941481475ff0f615a81/Python/compile.c#L55
+ https://github.com/python/cpython/blob/a58ebcc701dd6c43630df941481475ff0f615a81/Python/compile.c#L4442
+
+ In particular, this change is imposed whenever (n_args / 2) + n_kws > 15.
+
+ Different bytecode is generated for args depending on if n_args > 30
+ or n_args <= 30 and similarly if n_kws > 15 or n_kws <= 15.
+
+ This function unwraps the *args and **kwargs in the function call
+ and places these values directly into the args and kwargs of the call.
+ """
+ # All changes are local to the a single block
+ # so it can be traversed in any order.
+ errmsg = textwrap.dedent("""
+ CALL_FUNCTION_EX with **kwargs not supported.
+ If you are not using **kwargs this may indicate that
+ you have a large number of kwargs and are using inlined control
+ flow. You can resolve this issue by moving the control flow out of
+ the function call. For example, if you have
+
+ f(a=1 if flag else 0, ...)
+
+ Replace that with:
+
+ a_val = 1 if flag else 0
+ f(a=a_val, ...)""")
+
+ # Track which definitions have already been deleted
+ already_deleted_defs = collections.defaultdict(set)
+ for blk in func_ir.blocks.values():
+ blk_changed = False
+ new_body = []
+ for i, stmt in enumerate(blk.body):
+ if (
+ isinstance(stmt, ir.Assign)
+ and isinstance(stmt.value, ir.Expr)
+ and stmt.value.op == "call"
+ and stmt.value.varkwarg is not None
+ ):
+ blk_changed = True
+ call = stmt.value
+ args = call.args
+ kws = call.kws
+ # We need to check the call expression contents if
+ # it contains either vararg or varkwarg. If it contains
+ # varkwarg we need to update the IR. If it just contains
+ # vararg we don't need to update the IR, but we need to
+ # check if peep_hole_list_to_tuple failed to replace the
+ # vararg list with a tuple. If so, we output an error
+ # message with suggested code changes.
+ vararg = call.vararg
+ varkwarg = call.varkwarg
+ start_search = i - 1
+ # varkwarg should be defined second so we start there.
+ varkwarg_loc = start_search
+ keyword_def = None
+ found = False
+ while varkwarg_loc >= 0 and not found:
+ keyword_def = blk.body[varkwarg_loc]
+ if (
+ isinstance(keyword_def, ir.Assign)
+ and keyword_def.target.name == varkwarg.name
+ ):
+ found = True
+ else:
+ varkwarg_loc -= 1
+ if (
+ kws
+ or not found
+ or not (
+ isinstance(keyword_def.value, ir.Expr)
+ and keyword_def.value.op == "build_map"
+ )
+ ):
+ # If we couldn't find where the kwargs are created
+ # then it should be a normal **kwargs call
+ # so we produce an unsupported message.
+ raise UnsupportedBytecodeError(errmsg)
+ # Determine the kws
+ if keyword_def.value.items:
+ # n_kws <= 15 case.
+ # Here the IR looks like a series of
+ # constants, then the arguments and finally
+ # a build_map that contains all of the pairs.
+ # For Example:
+ #
+ # $const_n = const("arg_name")
+ # $arg_n = ...
+ # $kwargs_var = build_map(items=[
+ # ($const_0, $arg_0),
+ # ...,
+ # ($const_n, $arg_n),])
+ kws = _call_function_ex_replace_kws_small(
+ blk.body,
+ keyword_def.value,
+ new_body,
+ varkwarg_loc,
+ func_ir,
+ already_deleted_defs,
+ )
+ else:
+ # n_kws > 15 case.
+ # Here the IR is an initial empty build_map
+ # followed by a series of setitems with a constant
+ # key and then the argument.
+ # For example:
+ #
+ # $kwargs_var = build_map(items=[])
+ # $const_0 = const("arg_name")
+ # $arg_0 = ...
+ # $my_attr = getattr(const_0, attr=__setitem__)
+ # $unused_var = call $my_attr($const_0, $arg_0)
+ # ...
+ kws = _call_function_ex_replace_kws_large(
+ blk.body,
+ varkwarg.name,
+ varkwarg_loc,
+ i - 1,
+ new_body,
+ func_ir,
+ errmsg,
+ already_deleted_defs,
+ )
+ start_search = varkwarg_loc
+ # Vararg isn't required to be provided.
+ if vararg is not None:
+ if args:
+ # If we have vararg then args is expected to
+ # be an empty list.
+ raise UnsupportedBytecodeError(errmsg)
+ vararg_loc = start_search
+ args_def = None
+ found = False
+ while vararg_loc >= 0 and not found:
+ args_def = blk.body[vararg_loc]
+ if (
+ isinstance(args_def, ir.Assign)
+ and args_def.target.name == vararg.name
+ ):
+ found = True
+ else:
+ vararg_loc -= 1
+ if not found:
+ # If we couldn't find where the args are created
+ # then we can't handle this format.
+ raise UnsupportedBytecodeError(errmsg)
+ if (
+ isinstance(args_def.value, ir.Expr)
+ and args_def.value.op == "build_tuple"
+ ):
+ # n_args <= 30 case.
+ # Here the IR is a simple build_tuple containing
+ # all of the args.
+ # For example:
+ #
+ # $arg_n = ...
+ # $varargs = build_tuple(
+ # items=[$arg_0, ..., $arg_n]
+ # )
+ args = _call_function_ex_replace_args_small(
+ blk.body,
+ args_def.value,
+ new_body,
+ vararg_loc,
+ func_ir,
+ already_deleted_defs,
+ )
+ elif (
+ isinstance(args_def.value, ir.Expr)
+ and args_def.value.op == "list_to_tuple"
+ ):
+ # If there is a call with vararg we need to check
+ # if the list -> tuple conversion failed and if so
+ # throw an error.
+ raise UnsupportedBytecodeError(errmsg)
+ else:
+ # Here the IR is an initial empty build_tuple.
+ # Then for each arg, a new tuple with a single
+ # element is created and one by one these are
+ # added to a growing tuple.
+ # For example:
+ #
+ # $combo_tup_0 = build_tuple(items=[])
+ # $arg0 = ...
+ # $arg0_tup = build_tuple(items=[$arg0])
+ # $combo_tup_1 = $combo_tup_0 + $arg0_tup
+ # $arg1 = ...
+ # $arg1_tup = build_tuple(items=[$arg1])
+ # $combo_tup_2 = $combo_tup_1 + $arg1_tup
+ # ...
+ # $combo_tup_n = $combo_tup_{n-1} + $argn_tup
+ #
+ # In addition, the IR contains a final
+ # assignment for the varargs that looks like:
+ #
+ # $varargs_var = $combo_tup_n
+ #
+ # Here args_def is expected to be a simple assignment.
+ args = _call_function_ex_replace_args_large(
+ blk.body,
+ args_def,
+ new_body,
+ vararg_loc,
+ func_ir,
+ errmsg,
+ already_deleted_defs,
+ )
+ # Create a new call updating the args and kws
+ new_call = ir.Expr.call(
+ call.func, args, kws, call.loc, target=call.target
+ )
+ # Drop the existing definition for this stmt.
+ _remove_assignment_definition(
+ blk.body, i, func_ir, already_deleted_defs
+ )
+ # Update the statement
+ stmt = ir.Assign(new_call, stmt.target, stmt.loc)
+ # Update the definition
+ func_ir._definitions[stmt.target.name].append(new_call)
+ elif (
+ isinstance(stmt, ir.Assign)
+ and isinstance(stmt.value, ir.Expr)
+ and stmt.value.op == "call"
+ and stmt.value.vararg is not None
+ ):
+ # If there is a call with vararg we need to check
+ # if the list -> tuple conversion failed and if so
+ # throw an error.
+ call = stmt.value
+ vararg_name = call.vararg.name
+ if (
+ vararg_name in func_ir._definitions
+ and len(func_ir._definitions[vararg_name]) == 1
+ ):
+ # If this value is still a list to tuple raise the
+ # exception.
+ expr = func_ir._definitions[vararg_name][0]
+ if isinstance(expr, ir.Expr) and expr.op == "list_to_tuple":
+ raise UnsupportedBytecodeError(errmsg)
+
+ new_body.append(stmt)
+ # Replace the block body if we changed the IR
+ if blk_changed:
+ blk.body.clear()
+ blk.body.extend([x for x in new_body if x is not None])
+ return func_ir
+
+
+def peep_hole_list_to_tuple(func_ir):
+ """
+ This peephole rewrites a bytecode sequence new to Python 3.9 that looks
+ like e.g.:
+
+ def foo(a):
+ return (*a,)
+
+ 41 0 BUILD_LIST 0
+ 2 LOAD_FAST 0 (a)
+ 4 LIST_EXTEND 1
+ 6 LIST_TO_TUPLE
+ 8 RETURN_VAL
+
+ essentially, the unpacking of tuples is written as a list which is appended
+ to/extended and then "magicked" into a tuple by the new LIST_TO_TUPLE
+ opcode.
+
+ This peephole repeatedly analyses the bytecode in a block looking for a
+ window between a `LIST_TO_TUPLE` and `BUILD_LIST` and...
+
+ 1. Turns the BUILD_LIST into a BUILD_TUPLE
+ 2. Sets an accumulator's initial value as the target of the BUILD_TUPLE
+ 3. Searches for 'extend' on the original list and turns these into binary
+ additions on the accumulator.
+ 4. Searches for 'append' on the original list and turns these into a
+ `BUILD_TUPLE` which is then appended via binary addition to the
+ accumulator.
+ 5. Assigns the accumulator to the variable that exits the peephole and the
+ rest of the block/code refers to as the result of the unpack operation.
+ 6. Patches up
+ """
+ _DEBUG = False
+
+ # For all blocks
+ for offset, blk in func_ir.blocks.items():
+ # keep doing the peephole rewrite until nothing is left that matches
+ while True:
+ # first try and find a matching region
+ # i.e. BUILD_LIST......LIST_TO_TUPLE
+ def find_postive_region():
+ found = False
+ for idx in reversed(range(len(blk.body))):
+ stmt = blk.body[idx]
+ if isinstance(stmt, ir.Assign):
+ value = stmt.value
+ if (isinstance(value, ir.Expr) and
+ value.op == 'list_to_tuple'):
+ target_list = value.info[0]
+ found = True
+ bt = (idx, stmt)
+ if found:
+ if isinstance(stmt, ir.Assign):
+ if stmt.target.name == target_list:
+ region = (bt, (idx, stmt))
+ return region
+
+ region = find_postive_region()
+ # if there's a peep hole region then do something with it
+ if region is not None:
+ peep_hole = blk.body[region[1][0] : region[0][0]]
+ if _DEBUG:
+ print("\nWINDOW:")
+ for x in peep_hole:
+ print(x)
+ print("")
+
+ appends = []
+ extends = []
+ init = region[1][1]
+ const_list = init.target.name
+ # Walk through the peep_hole and find things that are being
+ # "extend"ed and "append"ed to the BUILD_LIST
+ for x in peep_hole:
+ if isinstance(x, ir.Assign):
+ if isinstance(x.value, ir.Expr):
+ expr = x.value
+ if (expr.op == 'getattr' and
+ expr.value.name == const_list):
+ # it's not strictly necessary to split out
+ # extends and appends, but it helps with
+ # debugging to do so!
+ if expr.attr == 'extend':
+ extends.append(x.target.name)
+ elif expr.attr == 'append':
+ appends.append(x.target.name)
+ else:
+ assert 0
+ # go back through the peep hole build new IR based on it.
+ new_hole = []
+
+ def append_and_fix(x):
+ """ Adds to the new_hole and fixes up definitions"""
+ new_hole.append(x)
+ if x.target.name in func_ir._definitions:
+ # if there's already a definition, drop it, should only
+ # be 1 as the way cpython emits the sequence for
+ # `list_to_tuple` should ensure this.
+ assert len(func_ir._definitions[x.target.name]) == 1
+ func_ir._definitions[x.target.name].clear()
+ func_ir._definitions[x.target.name].append(x.value)
+
+ the_build_list = init.target
+
+ # Do the transform on the peep hole
+ if _DEBUG:
+ print("\nBLOCK:")
+ blk.dump()
+
+ # This section basically accumulates list appends and extends
+ # as binop(+) on tuples, it drops all the getattr() for extend
+ # and append as they are now dead and replaced with binop(+).
+ # It also switches out the build_list for a build_tuple and then
+ # ensures everything is wired up and defined ok.
+ t2l_agn = region[0][1]
+ acc = the_build_list
+ for x in peep_hole:
+ if isinstance(x, ir.Assign):
+ if isinstance(x.value, ir.Expr):
+ expr = x.value
+ if expr.op == 'getattr':
+ if (x.target.name in extends or
+ x.target.name in appends):
+ # drop definition, it's being wholesale
+ # replaced.
+ func_ir._definitions.pop(x.target.name)
+ continue
+ else:
+ # a getattr on something we're not
+ # interested in
+ new_hole.append(x)
+ elif expr.op == 'call':
+ fname = expr.func.name
+ if fname in extends or fname in appends:
+ arg = expr.args[0]
+ if isinstance(arg, ir.Var):
+ tmp_name = "%s_var_%s" % (fname,
+ arg.name)
+ if fname in appends:
+ bt = ir.Expr.build_tuple([arg,],
+ expr.loc)
+ else:
+ # Extend as tuple
+ gv_tuple = ir.Global(
+ name="tuple", value=tuple,
+ loc=expr.loc,
+ )
+ tuple_var = arg.scope.redefine(
+ "$_list_extend_gv_tuple",
+ loc=expr.loc,
+ )
+ new_hole.append(
+ ir.Assign(
+ target=tuple_var,
+ value=gv_tuple,
+ loc=expr.loc,
+ ),
+ )
+ bt = ir.Expr.call(
+ tuple_var, (arg,), (),
+ loc=expr.loc,
+ )
+ var = ir.Var(arg.scope, tmp_name,
+ expr.loc)
+ asgn = ir.Assign(bt, var, expr.loc)
+ append_and_fix(asgn)
+ arg = var
+
+ # this needs to be a binary add
+ new = ir.Expr.binop(fn=operator.add,
+ lhs=acc,
+ rhs=arg,
+ loc=x.loc)
+ asgn = ir.Assign(new, x.target, expr.loc)
+ append_and_fix(asgn)
+ acc = asgn.target
+ else:
+ # there could be a call in the unpack, like
+ # *(a, x.append(y))
+ new_hole.append(x)
+ elif (expr.op == 'build_list' and
+ x.target.name == const_list):
+ new = ir.Expr.build_tuple(expr.items, expr.loc)
+ asgn = ir.Assign(new, x.target, expr.loc)
+ # Not a temporary any more
+ append_and_fix(asgn)
+ else:
+ new_hole.append(x)
+ else:
+ new_hole.append(x)
+
+ else:
+ # stick everything else in as-is
+ new_hole.append(x)
+ # Finally write the result back into the original build list as
+ # everything refers to it.
+ append_and_fix(ir.Assign(acc, t2l_agn.target,
+ the_build_list.loc))
+ if _DEBUG:
+ print("\nNEW HOLE:")
+ for x in new_hole:
+ print(x)
+
+ # and then update the block body with the modified region
+ cpy = blk.body[:]
+ head = cpy[:region[1][0]]
+ tail = blk.body[region[0][0] + 1:]
+ tmp = head + new_hole + tail
+ blk.body.clear()
+ blk.body.extend(tmp)
+
+ if _DEBUG:
+ print("\nDUMP post hole:")
+ blk.dump()
+
+ else:
+ # else escape
+ break
+
+ return func_ir
+
+
+def peep_hole_delete_with_exit(func_ir):
+ """
+ This rewrite removes variables used to store the `__exit__` function
+ loaded by SETUP_WITH.
+ """
+ dead_vars = set()
+
+ for blk in func_ir.blocks.values():
+ for stmt in blk.body:
+ # Any statement that uses a variable with the '$setup_with_exitfn'
+ # prefix is considered dead.
+ used = set(stmt.list_vars())
+ for v in used:
+ if v.name.startswith('$setup_with_exitfn'):
+ dead_vars.add(v)
+ # Any assignment that uses any of the dead variable is considered
+ # dead.
+ if used & dead_vars:
+ if isinstance(stmt, ir.Assign):
+ dead_vars.add(stmt.target)
+
+ new_body = []
+ for stmt in blk.body:
+ # Skip any statements that uses anyone of the dead variable.
+ if not (set(stmt.list_vars()) & dead_vars):
+ new_body.append(stmt)
+ blk.body.clear()
+ blk.body.extend(new_body)
+
+ return func_ir
+
+
+def peep_hole_fuse_dict_add_updates(func_ir):
+ """
+ This rewrite removes d1._update_from_bytecode(d2)
+ calls that are between two dictionaries, d1 and d2,
+ in the same basic block. This pattern can appear as a
+ result of Python 3.10 bytecode emission changes, which
+ prevent large constant literal dictionaries
+ (> 15 elements) from being constant. If both dictionaries
+ are constant dictionaries defined in the same block and
+ neither is used between the update call, then we replace d1
+ with a new definition that combines the two dictionaries. At
+ the bytecode translation stage we convert DICT_UPDATE into
+ _update_from_bytecode, so we know that _update_from_bytecode
+ always comes from the bytecode change and not user code.
+
+ Python 3.10 may also rewrite the individual dictionaries
+ as an empty build_map + many map_add. Here we again look
+ for an _update_from_bytecode, and if so we replace these
+ with a single constant dictionary.
+
+ When running this algorithm we can always safely remove d2.
+
+ This is the relevant section of the CPython 3.10 that causes
+ this bytecode change:
+ https://github.com/python/cpython/blob/3.10/Python/compile.c#L4048
+ """
+
+ # This algorithm fuses build_map expressions into the largest
+ # possible build map before use. For example, if we have an
+ # IR that looks like this:
+ #
+ # $d1 = build_map([])
+ # $key = const("a")
+ # $value = const(2)
+ # $setitem_func = getattr($d1, "__setitem__")
+ # $unused1 = call (setitem_func, ($key, $value))
+ # $key2 = const("b")
+ # $value2 = const(3)
+ # $d2 = build_map([($key2, $value2)])
+ # $update_func = getattr($d1, "_update_from_bytecode")
+ # $unused2 = call ($update_func, ($d2,))
+ # $othervar = None
+ # $retvar = cast($othervar)
+ # return $retvar
+ #
+ # Then the IR is rewritten such that any __setitem__ and
+ # _update_from_bytecode operations are fused into the original buildmap.
+ # The new buildmap is then added to the
+ # last location where it had previously had encountered a __setitem__,
+ # _update_from_bytecode, or build_map before any other uses.
+ # The new IR would look like:
+ #
+ # $key = const("a")
+ # $value = const(2)
+ # $key2 = const("b")
+ # $value2 = const(3)
+ # $d1 = build_map([($key, $value), ($key2, $value2)])
+ # $othervar = None
+ # $retvar = cast($othervar)
+ # return $retvar
+ #
+ # Note that we don't push $d1 to the bottom of the block. This is because
+ # some values may be found below this block (e.g pop_block) that are pattern
+ # matched in other locations, such as objmode handling. It should be safe to
+ # move a map to the last location at which there was _update_from_bytecode.
+
+ errmsg = textwrap.dedent("""
+ A DICT_UPDATE op-code was encountered that could not be replaced.
+ If you have created a large constant dictionary, this may
+ be an an indication that you are using inlined control
+ flow. You can resolve this issue by moving the control flow out of
+ the dicitonary constructor. For example, if you have
+
+ d = {a: 1 if flag else 0, ...)
+
+ Replace that with:
+
+ a_val = 1 if flag else 0
+ d = {a: a_val, ...)""")
+
+ already_deleted_defs = collections.defaultdict(set)
+ for blk in func_ir.blocks.values():
+ new_body = []
+ # literal map var name -> block idx of the original build_map
+ lit_map_def_idx = {}
+ # literal map var name -> list(map_uses)
+ # This is the index of every build_map or __setitem__
+ # in the IR that will need to be removed if the map
+ # is updated.
+ lit_map_use_idx = collections.defaultdict(list)
+ # literal map var name -> list of key/value items for build map
+ map_updates = {}
+ blk_changed = False
+
+ for i, stmt in enumerate(blk.body):
+ # What instruction should we append
+ new_inst = stmt
+ # Name that should be skipped when tracking used
+ # vars in statement. This is always the lhs with
+ # a build_map.
+ stmt_build_map_out = None
+ if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Expr):
+ if stmt.value.op == "build_map":
+ # Skip the output build_map when looking for used vars.
+ stmt_build_map_out = stmt.target.name
+ # If we encounter a build map add it to the
+ # tracked maps.
+ lit_map_def_idx[stmt.target.name] = i
+ lit_map_use_idx[stmt.target.name].append(i)
+ map_updates[stmt.target.name] = stmt.value.items.copy()
+ elif stmt.value.op == "call" and i > 0:
+ # If we encounter a call we may need to replace
+ # the body
+ func_name = stmt.value.func.name
+ # If we have an update or a setitem
+ # it will be the previous expression.
+ getattr_stmt = blk.body[i - 1]
+ args = stmt.value.args
+ if (
+ isinstance(getattr_stmt, ir.Assign)
+ and getattr_stmt.target.name == func_name
+ and isinstance(getattr_stmt.value, ir.Expr)
+ and getattr_stmt.value.op == "getattr"
+ and getattr_stmt.value.attr in (
+ "__setitem__", "_update_from_bytecode"
+ )
+ ):
+ update_map_name = getattr_stmt.value.value.name
+ attr = getattr_stmt.value.attr
+ if (attr == "__setitem__"
+ and update_map_name in lit_map_use_idx):
+ # If we have a setitem, update the lists
+ map_updates[update_map_name].append(args)
+ # Update the list of instructions that would
+ # need to be removed to include the setitem
+ # and the the getattr
+ lit_map_use_idx[update_map_name].extend([i - 1, i])
+ elif attr == "_update_from_bytecode":
+ d2_map_name = args[0].name
+ if (update_map_name in lit_map_use_idx
+ and d2_map_name in lit_map_use_idx):
+ # If we have an update and the arg is also
+ # a literal dictionary, fuse the lists.
+ map_updates[update_map_name].extend(
+ map_updates[d2_map_name]
+ )
+ # Delete the old IR for d1 and d2
+ lit_map_use_idx[update_map_name].extend(
+ lit_map_use_idx[d2_map_name]
+ )
+ lit_map_use_idx[update_map_name].append(i - 1)
+ for linenum in lit_map_use_idx[update_map_name]:
+ # Drop the existing definition.
+ _remove_assignment_definition(
+ blk.body,
+ linenum,
+ func_ir,
+ already_deleted_defs,
+ )
+ # Delete it from the new block
+ new_body[linenum] = None
+ # Delete the maps from dicts
+ del lit_map_def_idx[d2_map_name]
+ del lit_map_use_idx[d2_map_name]
+ del map_updates[d2_map_name]
+ # Add d1 as the new instruction, removing the
+ # old definition.
+ _remove_assignment_definition(
+ blk.body, i, func_ir, already_deleted_defs
+ )
+ new_inst = _build_new_build_map(
+ func_ir,
+ update_map_name,
+ blk.body,
+ lit_map_def_idx[update_map_name],
+ map_updates[update_map_name],
+ )
+ # Update d1 in lit_map_use_idx to just the new
+ # definition and clear the previous list.
+ lit_map_use_idx[update_map_name].clear()
+ lit_map_use_idx[update_map_name].append(i)
+ # Mark that this block has been modified
+ blk_changed = True
+ else:
+ # If we cannot remove _update_from_bytecode
+ # Then raise an error for the user.
+ raise UnsupportedBytecodeError(errmsg)
+
+ # Check if we need to drop any maps from being tracked.
+ # Skip the setitem/_update_from_bytecode getattr that
+ # will be removed when handling their call in the next
+ # iteration.
+ if not (
+ isinstance(stmt, ir.Assign)
+ and isinstance(stmt.value, ir.Expr)
+ and stmt.value.op == "getattr"
+ and stmt.value.value.name in lit_map_use_idx
+ and stmt.value.attr in ("__setitem__", "_update_from_bytecode")
+ ):
+ for var in stmt.list_vars():
+ # If a map is used it cannot be fused later in
+ # the block. As a result we delete it from
+ # the dicitonaries
+ if (
+ var.name in lit_map_use_idx
+ and var.name != stmt_build_map_out
+ ):
+ del lit_map_def_idx[var.name]
+ del lit_map_use_idx[var.name]
+ del map_updates[var.name]
+
+ # Append the instruction to the new block
+ new_body.append(new_inst)
+
+ if blk_changed:
+ # If the block is changed replace the block body.
+ blk.body.clear()
+ blk.body.extend([x for x in new_body if x is not None])
+
+ return func_ir
+
+
+def peep_hole_split_at_pop_block(func_ir):
+ """
+ Split blocks that contain ir.PopBlock.
+
+ This rewrite restores the IR structure to pre 3.11 so that withlifting
+ can work correctly.
+ """
+ new_block_map = {}
+ sorted_blocks = sorted(func_ir.blocks.items())
+ for blk_idx, (label, blk) in enumerate(sorted_blocks):
+ # Gather locations of PopBlock
+ pop_block_locs = []
+ for i, inst in enumerate(blk.body):
+ if isinstance(inst, ir.PopBlock):
+ pop_block_locs.append(i)
+ # Rewrite block with PopBlock
+ if pop_block_locs:
+ new_blocks = []
+ for i in pop_block_locs:
+ before_blk = ir.Block(blk.scope, loc=blk.loc)
+ before_blk.body.extend(blk.body[:i])
+ new_blocks.append(before_blk)
+
+ popblk_blk = ir.Block(blk.scope, loc=blk.loc)
+ popblk_blk.body.append(blk.body[i])
+ new_blocks.append(popblk_blk)
+ # Add jump instructions
+ prev_label = label
+ for newblk in new_blocks:
+ new_block_map[prev_label] = newblk
+ next_label = prev_label + 1
+ newblk.body.append(ir.Jump(next_label, loc=blk.loc))
+ prev_label = next_label
+ # Check prev_label does not exceed current new block label
+ if blk_idx + 1 < len(sorted_blocks):
+ if prev_label >= sorted_blocks[blk_idx + 1][0]:
+ # Panic! Due to heuristic in with-lifting, block labels
+ # must be monotonically increasing. We cannot continue if we
+ # run out of usable label between the two blocks.
+ raise errors.InternalError("POP_BLOCK peephole failed")
+ # Add tail block, which will get the original terminator
+ tail_blk = ir.Block(blk.scope, loc=blk.loc)
+ tail_blk.body.extend(blk.body[pop_block_locs[-1] + 1:])
+ new_block_map[prev_label] = tail_blk
+
+ func_ir.blocks.update(new_block_map)
+ return func_ir
+
+
+def _build_new_build_map(func_ir, name, old_body, old_lineno, new_items):
+ """
+ Create a new build_map with a new set of key/value items
+ but all the other info the same.
+ """
+ old_assign = old_body[old_lineno]
+ old_target = old_assign.target
+ old_bm = old_assign.value
+ # Build the literals
+ literal_keys = []
+ # Track the constant key/values to set the literal_value
+ # field of build_map properly
+ values = []
+ for pair in new_items:
+ k, v = pair
+ key_def = guard(get_definition, func_ir, k)
+ if isinstance(key_def, (ir.Const, ir.Global, ir.FreeVar)):
+ literal_keys.append(key_def.value)
+ value_def = guard(get_definition, func_ir, v)
+ if isinstance(value_def, (ir.Const, ir.Global, ir.FreeVar)):
+ values.append(value_def.value)
+ else:
+ # Append unknown value if not a literal.
+ values.append(_UNKNOWN_VALUE(v.name))
+
+ value_indexes = {}
+ if len(literal_keys) == len(new_items):
+ # All keys must be literals to have any literal values.
+ literal_value = {x: y for x, y in zip(literal_keys, values)}
+ for i, k in enumerate(literal_keys):
+ value_indexes[k] = i
+ else:
+ literal_value = None
+
+ # Construct a new build map.
+ new_bm = ir.Expr.build_map(
+ items=new_items,
+ size=len(new_items),
+ literal_value=literal_value,
+ value_indexes=value_indexes,
+ loc=old_bm.loc,
+ )
+
+ # The previous definition has already been removed
+ # when updating the IR in peep_hole_fuse_dict_add_updates
+ func_ir._definitions[name].append(new_bm)
+
+ # Return a new assign.
+ return ir.Assign(
+ new_bm, ir.Var(old_target.scope, name, old_target.loc), new_bm.loc
+ )
+
+
+class Interpreter(object):
+ """A bytecode interpreter that builds up the IR.
+ """
+
+ _DEBUG_PRINT = False
+
+ def __init__(self, func_id):
+ self.func_id = func_id
+ if self._DEBUG_PRINT:
+ print(func_id.func)
+ self.arg_count = func_id.arg_count
+ self.arg_names = func_id.arg_names
+ self.loc = self.first_loc = ir.Loc.from_function_id(func_id)
+ self.is_generator = func_id.is_generator
+
+ # { inst offset : ir.Block }
+ self.blocks = {}
+ # { name: [definitions] } of local variables
+ self.definitions = collections.defaultdict(list)
+ # A set to keep track of all exception variables.
+ # To be used in _legalize_exception_vars()
+ self._exception_vars = set()
+
+ def interpret(self, bytecode):
+ """
+ Generate IR for this bytecode.
+ """
+ self.bytecode = bytecode
+
+ self.scopes = []
+ global_scope = ir.Scope(parent=None, loc=self.loc)
+ self.scopes.append(global_scope)
+
+ flow = Flow(bytecode)
+ flow.run()
+ self.dfa = AdaptDFA(flow)
+ self.cfa = AdaptCFA(flow)
+ if config.DUMP_CFG:
+ self.cfa.dump()
+
+ # Temp states during interpretation
+ self.current_block = None
+ self.current_block_offset = None
+ last_active_offset = 0
+ for _, inst_blocks in self.cfa.blocks.items():
+ if inst_blocks.body:
+ last_active_offset = max(last_active_offset,
+ max(inst_blocks.body))
+ self.last_active_offset = last_active_offset
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ self.active_exception_entries = tuple(
+ [entry for entry in self.bytecode.exception_entries
+ if entry.start < self.last_active_offset])
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+ self.syntax_blocks = []
+ self.dfainfo = None
+
+ self.scopes.append(ir.Scope(parent=self.current_scope, loc=self.loc))
+
+ # Interpret loop
+ for inst, kws in self._iter_inst():
+ self._dispatch(inst, kws)
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ # Insert end of try markers
+ self._end_try_blocks()
+ elif PYVERSION in ((3, 10),):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+ self._legalize_exception_vars()
+ # Prepare FunctionIR
+ func_ir = ir.FunctionIR(self.blocks, self.is_generator, self.func_id,
+ self.first_loc, self.definitions,
+ self.arg_count, self.arg_names)
+ _logger.debug(func_ir.dump_to_string())
+
+ # post process the IR to rewrite opcodes/byte sequences that are too
+ # involved to risk handling as part of direct interpretation
+ peepholes = []
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ peepholes.append(peep_hole_split_at_pop_block)
+ if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+ peepholes.append(peep_hole_list_to_tuple)
+ peepholes.append(peep_hole_delete_with_exit)
+ if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+ # peep_hole_call_function_ex_to_call_function_kw
+ # depends on peep_hole_list_to_tuple converting
+ # any large number of arguments from a list to a
+ # tuple.
+ peepholes.append(peep_hole_call_function_ex_to_call_function_kw)
+ peepholes.append(peep_hole_fuse_dict_add_updates)
+
+ post_processed_ir = self.post_process(peepholes, func_ir)
+
+ return post_processed_ir
+
+ def post_process(self, peepholes, func_ir):
+ for peep in peepholes:
+ func_ir = peep(func_ir)
+ return func_ir
+
+ def _end_try_blocks(self):
+ """Closes all try blocks by inserting the required marker at the
+ exception handler
+
+ This is only needed for py3.11 because of the changes in exception
+ handling. This merely maps the new py3.11 semantics back to the old way.
+
+ What the code does:
+
+ - For each block, compute the difference of blockstack to its incoming
+ blocks' blockstack.
+ - If the incoming blockstack has an extra TRY, the current block must
+ be the EXCEPT block and we need to insert a marker.
+
+ See also: _insert_try_block_end
+ """
+ assert PYVERSION in ((3, 11), (3, 12), (3, 13))
+ graph = self.cfa.graph
+ for offset, block in self.blocks.items():
+ # Get current blockstack
+ cur_bs = self.dfa.infos[offset].blockstack
+ # Check blockstack of the incoming blocks
+ for inc, _ in graph.predecessors(offset):
+ inc_bs = self.dfa.infos[inc].blockstack
+
+ # find first diff in the blockstack
+ for i, (x, y) in enumerate(zip(cur_bs, inc_bs)):
+ if x != y:
+ break
+ else:
+ i = min(len(cur_bs), len(inc_bs))
+
+ def do_change(remain):
+ while remain:
+ ent = remain.pop()
+ if ent['kind'] == BlockKind('TRY'):
+ # Extend block with marker for end of try
+ self.current_block = block
+ oldbody = list(block.body)
+ block.body.clear()
+ self._insert_try_block_end()
+ block.body.extend(oldbody)
+ return True
+
+ if do_change(list(inc_bs[i:])):
+ break
+
+ def _legalize_exception_vars(self):
+ """Search for unsupported use of exception variables.
+ Note, they cannot be stored into user variable.
+ """
+ # Build a set of exception variables
+ excvars = self._exception_vars.copy()
+ # Propagate the exception variables to LHS of assignment
+ for varname, defnvars in self.definitions.items():
+ for v in defnvars:
+ if isinstance(v, ir.Var):
+ k = v.name
+ if k in excvars:
+ excvars.add(varname)
+ # Filter out the user variables.
+ uservar = list(filter(lambda x: not x.startswith('$'), excvars))
+ if uservar:
+ # Complain about the first user-variable storing an exception
+ first = uservar[0]
+ loc = self.current_scope.get(first).loc
+ msg = "Exception object cannot be stored into variable ({})."
+ raise errors.UnsupportedBytecodeError(msg.format(first), loc=loc)
+
+ def init_first_block(self):
+ # Define variables receiving the function arguments
+ for index, name in enumerate(self.arg_names):
+ val = ir.Arg(index=index, name=name, loc=self.loc)
+ self.store(val, name)
+
+ def _iter_inst(self):
+ for blkct, block in enumerate(self.cfa.iterliveblocks()):
+ firstinst = self.bytecode[block.offset]
+ # If its an END_FOR instruction, the start location of block
+ # is set to start of the FOR loop, so take the location of
+ # next instruction. This only affects the source location
+ # marking and has no impact to semantic.
+ if firstinst.opname == 'END_FOR':
+ firstinst = self.bytecode[firstinst.next]
+ self.loc = self.loc.with_lineno(firstinst.lineno)
+ self._start_new_block(block.offset)
+ if blkct == 0:
+ # Is first block
+ self.init_first_block()
+ for offset, kws in self.dfainfo.insts:
+ inst = self.bytecode[offset]
+ self.loc = self.loc.with_lineno(inst.lineno)
+ yield inst, kws
+ self._end_current_block()
+
+ def _start_new_block(self, offset):
+ oldblock = self.current_block
+ self.insert_block(offset)
+
+ tryblk = self.dfainfo.active_try_block if self.dfainfo else None
+ # Ensure the last block is terminated
+ if oldblock is not None and not oldblock.is_terminated:
+ # Handle ending try block.
+ # If there's an active try-block and the handler block is live.
+ if tryblk is not None and tryblk['end'] in self.cfa.graph.nodes():
+ # We are in a try-block, insert a branch to except-block.
+ # This logic cannot be in self._end_current_block()
+ # because we don't know the non-raising next block-offset.
+ branch = ir.Branch(
+ cond=self.get('$exception_check'),
+ truebr=tryblk['end'],
+ falsebr=offset,
+ loc=self.loc,
+ )
+ oldblock.append(branch)
+ # Handle normal case
+ else:
+ jmp = ir.Jump(offset, loc=self.loc)
+ oldblock.append(jmp)
+
+ # Get DFA block info
+ self.dfainfo = self.dfa.infos[self.current_block_offset]
+ self.assigner = Assigner()
+ # Check out-of-scope syntactic-block
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ # This is recreating pre-3.11 code structure
+ while self.syntax_blocks:
+ if offset >= self.syntax_blocks[-1].exit:
+ synblk = self.syntax_blocks.pop()
+ if isinstance(synblk, ir.With):
+ self.current_block.append(ir.PopBlock(self.loc))
+ else:
+ break
+ # inject try block:
+ newtryblk = self.dfainfo.active_try_block
+ if newtryblk is not None:
+ if newtryblk is not tryblk:
+ self._insert_try_block_begin()
+ elif PYVERSION in ((3, 10),):
+ while self.syntax_blocks:
+ if offset >= self.syntax_blocks[-1].exit:
+ self.syntax_blocks.pop()
+ else:
+ break
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def _end_current_block(self):
+ # Handle try block
+ if not self.current_block.is_terminated:
+ tryblk = self.dfainfo.active_try_block
+ if tryblk is not None:
+ self._insert_exception_check()
+ # Handle normal block cleanup
+ self._remove_unused_temporaries()
+ self._insert_outgoing_phis()
+
+ def _inject_call(self, func, gv_name, res_name=None):
+ """A helper function to inject a call to *func* which is a python
+ function.
+ Parameters
+ ----------
+ func : callable
+ The function object to be called.
+ gv_name : str
+ The variable name to be used to store the function object.
+ res_name : str; optional
+ The variable name to be used to store the call result.
+ If ``None``, a name is created automatically.
+ """
+ gv_fn = ir.Global(gv_name, func, loc=self.loc)
+ self.store(value=gv_fn, name=gv_name, redefine=True)
+ callres = ir.Expr.call(self.get(gv_name), (), (), loc=self.loc)
+ res_name = res_name or '$callres_{}'.format(gv_name)
+ self.store(value=callres, name=res_name, redefine=True)
+
+ def _insert_try_block_begin(self):
+ """Insert IR-nodes to mark the start of a `try` block.
+ """
+ self._inject_call(eh.mark_try_block, 'mark_try_block')
+
+ def _insert_try_block_end(self):
+ """Insert IR-nodes to mark the end of a `try` block.
+ """
+ self._inject_call(eh.end_try_block, 'end_try_block')
+
+ def _insert_exception_variables(self):
+ """Insert IR-nodes to initialize the exception variables.
+ """
+ tryblk = self.dfainfo.active_try_block
+ # Get exception variables
+ endblk = tryblk['end']
+ edgepushed = self.dfainfo.outgoing_edgepushed.get(endblk)
+ # Note: the last value on the stack is the exception value
+ # Note: due to the current limitation, all exception variables are None
+ if edgepushed:
+ const_none = ir.Const(value=None, loc=self.loc)
+ # For each variable going to the handler block.
+ for var in edgepushed:
+ if var in self.definitions:
+ raise AssertionError(
+ "exception variable CANNOT be defined by other code",
+ )
+ self.store(value=const_none, name=var)
+ self._exception_vars.add(var)
+
+ def _insert_exception_check(self):
+ """Called before the end of a block to inject checks if raised.
+ """
+ self._insert_exception_variables()
+ # Do exception check
+ self._inject_call(eh.exception_check, 'exception_check',
+ '$exception_check')
+
+ def _remove_unused_temporaries(self):
+ """
+ Remove assignments to unused temporary variables from the
+ current block.
+ """
+ new_body = []
+ replaced_var = {}
+ for inst in self.current_block.body:
+ # the same temporary is assigned to multiple variables in cases
+ # like a = b[i] = 1, so need to handle replaced temporaries in
+ # later setitem/setattr nodes
+ if (isinstance(inst, (ir.SetItem, ir.SetAttr))
+ and inst.value.name in replaced_var):
+ inst.value = replaced_var[inst.value.name]
+ elif isinstance(inst, ir.Assign):
+ if (inst.target.is_temp
+ and inst.target.name in self.assigner.unused_dests):
+ continue
+ # the same temporary is assigned to multiple variables in cases
+ # like a = b = 1, so need to handle replaced temporaries in
+ # later assignments
+ if (isinstance(inst.value, ir.Var)
+ and inst.value.name in replaced_var):
+ inst.value = replaced_var[inst.value.name]
+ new_body.append(inst)
+ continue
+ # chained unpack cases may reuse temporary
+ # e.g. a = (b, c) = (x, y)
+ if (isinstance(inst.value, ir.Expr)
+ and inst.value.op == "exhaust_iter"
+ and inst.value.value.name in replaced_var):
+ inst.value.value = replaced_var[inst.value.value.name]
+ new_body.append(inst)
+ continue
+ # eliminate temporary variables that are assigned to user
+ # variables right after creation. E.g.:
+ # $1 = f(); a = $1 -> a = f()
+ # the temporary variable is not reused elsewhere since CPython
+ # bytecode is stack-based and this pattern corresponds to a pop
+ if (isinstance(inst.value, ir.Var) and inst.value.is_temp
+ and new_body and isinstance(new_body[-1], ir.Assign)):
+ prev_assign = new_body[-1]
+ # _var_used_in_binop check makes sure we don't create a new
+ # inplace binop operation which can fail
+ # (see TestFunctionType.test_in_iter_func_call)
+ if (prev_assign.target.name == inst.value.name
+ and not self._var_used_in_binop(
+ inst.target.name, prev_assign.value)):
+ replaced_var[inst.value.name] = inst.target
+ prev_assign.target = inst.target
+ # replace temp var definition in target with proper defs
+ self.definitions[inst.target.name].remove(inst.value)
+ self.definitions[inst.target.name].extend(
+ self.definitions.pop(inst.value.name)
+ )
+ continue
+
+ new_body.append(inst)
+
+ self.current_block.body = new_body
+
+ def _var_used_in_binop(self, varname, expr):
+ """return True if 'expr' is a binary expression and 'varname' is used
+ in it as an argument
+ """
+ return (isinstance(expr, ir.Expr)
+ and expr.op in ("binop", "inplace_binop")
+ and (varname == expr.lhs.name or varname == expr.rhs.name))
+
+ def _insert_outgoing_phis(self):
+ """
+ Add assignments to forward requested outgoing values
+ to subsequent blocks.
+ """
+ for phiname, varname in self.dfainfo.outgoing_phis.items():
+ target = self.current_scope.get_or_define(phiname,
+ loc=self.loc)
+ try:
+ val = self.get(varname)
+ except ir.NotDefinedError:
+ # Hack to make sure exception variables are defined
+ assert PYVERSION in ((3, 11), (3, 12), (3, 13)), \
+ "unexpected missing definition"
+ val = ir.Const(value=None, loc=self.loc)
+ stmt = ir.Assign(value=val, target=target,
+ loc=self.loc)
+ self.definitions[target.name].append(stmt.value)
+ if not self.current_block.is_terminated:
+ self.current_block.append(stmt)
+ else:
+ self.current_block.insert_before_terminator(stmt)
+
+ def get_global_value(self, name):
+ """
+ Get a global value from the func_global (first) or
+ as a builtins (second). If both failed, return a ir.UNDEFINED.
+ """
+ try:
+ return self.func_id.func.__globals__[name]
+ except KeyError:
+ return getattr(builtins, name, ir.UNDEFINED)
+
+ def get_closure_value(self, index):
+ """
+ Get a value from the cell contained in this function's closure.
+ If not set, return a ir.UNDEFINED.
+ """
+ cell = self.func_id.func.__closure__[index]
+ try:
+ return cell.cell_contents
+ except ValueError:
+ return ir.UNDEFINED
+
+ @property
+ def current_scope(self):
+ return self.scopes[-1]
+
+ @property
+ def code_consts(self):
+ return self.bytecode.co_consts
+
+ @property
+ def code_locals(self):
+ return self.bytecode.co_varnames
+
+ @property
+ def code_names(self):
+ return self.bytecode.co_names
+
+ @property
+ def code_cellvars(self):
+ return self.bytecode.co_cellvars
+
+ @property
+ def code_freevars(self):
+ return self.bytecode.co_freevars
+
+ def _dispatch(self, inst, kws):
+ if self._DEBUG_PRINT:
+ print(inst)
+ assert self.current_block is not None
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ if self.syntax_blocks:
+ top = self.syntax_blocks[-1]
+ if isinstance(top, ir.With) :
+ if inst.offset >= top.exit:
+ self.current_block.append(ir.PopBlock(loc=self.loc))
+ self.syntax_blocks.pop()
+ elif PYVERSION in ((3, 10),):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ fname = "op_%s" % inst.opname.replace('+', '_')
+ try:
+ fn = getattr(self, fname)
+ except AttributeError:
+ raise NotImplementedError(inst)
+ else:
+ try:
+ return fn(inst, **kws)
+ except errors.NotDefinedError as e:
+ if e.loc is None:
+ loc = self.loc
+ else:
+ loc = e.loc
+
+ err = errors.NotDefinedError(e.name, loc=loc)
+ if not config.FULL_TRACEBACKS:
+ raise err from None
+ else:
+ m = f"handling op: {inst} | offset: {inst.offset}"
+ err.add_context(m)
+ err.add_context(self.bytecode.dump())
+ raise err
+
+ # --- Scope operations ---
+
+ def store(self, value, name, redefine=False):
+ """
+ Store *value* (a Expr or Var instance) into the variable named *name*
+ (a str object). Returns the target variable.
+ """
+ if redefine or self.current_block_offset in self.cfa.backbone:
+ rename = not (name in self.code_cellvars)
+ target = self.current_scope.redefine(name, loc=self.loc,
+ rename=rename)
+ else:
+ target = self.current_scope.get_or_define(name, loc=self.loc)
+ if isinstance(value, ir.Var):
+ value = self.assigner.assign(value, target)
+ stmt = ir.Assign(value=value, target=target, loc=self.loc)
+ self.current_block.append(stmt)
+ self.definitions[target.name].append(value)
+ return target
+
+ def get(self, name):
+ """
+ Get the variable (a Var instance) with the given *name*.
+ """
+ # Implicit argument for comprehension starts with '.'
+ # See Parameter class in inspect.py (from Python source)
+ if name[0] == '.' and name[1:].isdigit():
+ name = 'implicit{}'.format(name[1:])
+
+ # Try to simplify the variable lookup by returning an earlier
+ # variable assigned to *name*.
+ var = self.assigner.get_assignment_source(name)
+ if var is None:
+ var = self.current_scope.get(name)
+ return var
+
+ # --- Block operations ---
+
+ def insert_block(self, offset, scope=None, loc=None):
+ scope = scope or self.current_scope
+ loc = loc or self.loc
+ blk = ir.Block(scope=scope, loc=loc)
+ self.blocks[offset] = blk
+ self.current_block = blk
+ self.current_block_offset = offset
+ return blk
+
+ # --- Bytecode handlers ---
+
+ def op_NOP(self, inst):
+ pass
+
+ def op_RESUME(self, inst):
+ pass
+
+ def op_CACHE(self, inst):
+ pass
+
+ def op_PRECALL(self, inst):
+ pass
+
+ def op_PUSH_NULL(self, inst):
+ pass
+
+ def op_RETURN_GENERATOR(self, inst):
+ pass
+
+ def op_PRINT_ITEM(self, inst, item, printvar, res):
+ item = self.get(item)
+ printgv = ir.Global("print", print, loc=self.loc)
+ self.store(value=printgv, name=printvar)
+ call = ir.Expr.call(self.get(printvar), (item,), (), loc=self.loc)
+ self.store(value=call, name=res)
+
+ def op_PRINT_NEWLINE(self, inst, printvar, res):
+ printgv = ir.Global("print", print, loc=self.loc)
+ self.store(value=printgv, name=printvar)
+ call = ir.Expr.call(self.get(printvar), (), (), loc=self.loc)
+ self.store(value=call, name=res)
+
+ def op_UNPACK_SEQUENCE(self, inst, iterable, stores, tupleobj):
+ count = len(stores)
+ # Exhaust the iterable into a tuple-like object
+ tup = ir.Expr.exhaust_iter(value=self.get(iterable), loc=self.loc,
+ count=count)
+ self.store(name=tupleobj, value=tup)
+
+ # then index the tuple-like object to extract the values
+ for i, st in enumerate(stores):
+ expr = ir.Expr.static_getitem(self.get(tupleobj),
+ index=i, index_var=None,
+ loc=self.loc)
+ self.store(expr, st)
+
+ def op_FORMAT_SIMPLE(self, inst, value, res, strvar):
+ # Same as FORMAT_VALUE
+ return self.op_FORMAT_VALUE(inst, value, res, strvar)
+
+ def op_FORMAT_VALUE(self, inst, value, res, strvar):
+ """
+ FORMAT_VALUE(flags): flags argument specifies format spec which is not
+ supported yet. Currently, str() is simply called on the value.
+ https://docs.python.org/3/library/dis.html#opcode-FORMAT_VALUE
+ """
+ value = self.get(value)
+ strgv = ir.Global("str", str, loc=self.loc)
+ self.store(value=strgv, name=strvar)
+ call = ir.Expr.call(self.get(strvar), (value,), (), loc=self.loc)
+ self.store(value=call, name=res)
+
+ def op_BUILD_STRING(self, inst, strings, tmps):
+ """
+ BUILD_STRING(count): Concatenates count strings.
+ Required for supporting f-strings.
+ https://docs.python.org/3/library/dis.html#opcode-BUILD_STRING
+ """
+ count = inst.arg
+ # corner case: f""
+ if count == 0:
+ const = ir.Const("", loc=self.loc)
+ self.store(const, tmps[-1])
+ return
+
+ prev = self.get(strings[0])
+ for other, tmp in zip(strings[1:], tmps):
+ other = self.get(other)
+ expr = ir.Expr.binop(
+ operator.add, lhs=prev, rhs=other, loc=self.loc
+ )
+ self.store(expr, tmp)
+ prev = self.get(tmp)
+
+ def op_BUILD_SLICE(self, inst, start, stop, step, res, slicevar):
+ start = self.get(start)
+ stop = self.get(stop)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ if step is None:
+ sliceinst = ir.Expr.call(self.get(slicevar), (start, stop), (),
+ loc=self.loc)
+ else:
+ step = self.get(step)
+ sliceinst = ir.Expr.call(self.get(slicevar), (start, stop, step),
+ (), loc=self.loc)
+ self.store(value=sliceinst, name=res)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_BINARY_SLICE(self, inst, start, end, container, res, slicevar,
+ temp_res):
+ start = self.get(start)
+ end = self.get(end)
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+ sliceinst = ir.Expr.call(self.get(slicevar), (start, end), (),
+ loc=self.loc)
+ self.store(value=sliceinst, name=temp_res)
+ index = self.get(temp_res)
+ target = self.get(container)
+ expr = ir.Expr.getitem(target, index=index, loc=self.loc)
+ self.store(expr, res)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_STORE_SLICE(self, inst, start, end, container, value, res,
+ slicevar):
+ start = self.get(start)
+ end = self.get(end)
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+ sliceinst = ir.Expr.call(self.get(slicevar), (start, end), (),
+ loc=self.loc)
+ self.store(value=sliceinst, name=res)
+ index = self.get(res)
+ target = self.get(container)
+ value = self.get(value)
+
+ stmt = ir.SetItem(target=target, index=index, value=value,
+ loc=self.loc)
+ self.current_block.append(stmt)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_SLICE_0(self, inst, base, res, slicevar, indexvar, nonevar):
+ base = self.get(base)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ index = ir.Expr.call(self.get(slicevar), (none, none), (), loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ expr = ir.Expr.getitem(base, self.get(indexvar), loc=self.loc)
+ self.store(value=expr, name=res)
+
+ def op_SLICE_1(self, inst, base, start, nonevar, res, slicevar, indexvar):
+ base = self.get(base)
+ start = self.get(start)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (start, none), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ expr = ir.Expr.getitem(base, self.get(indexvar), loc=self.loc)
+ self.store(value=expr, name=res)
+
+ def op_SLICE_2(self, inst, base, nonevar, stop, res, slicevar, indexvar):
+ base = self.get(base)
+ stop = self.get(stop)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (none, stop,), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ expr = ir.Expr.getitem(base, self.get(indexvar), loc=self.loc)
+ self.store(value=expr, name=res)
+
+ def op_SLICE_3(self, inst, base, start, stop, res, slicevar, indexvar):
+ base = self.get(base)
+ start = self.get(start)
+ stop = self.get(stop)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (start, stop), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ expr = ir.Expr.getitem(base, self.get(indexvar), loc=self.loc)
+ self.store(value=expr, name=res)
+
+ def op_STORE_SLICE_0(self, inst, base, value, slicevar, indexvar, nonevar):
+ base = self.get(base)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ index = ir.Expr.call(self.get(slicevar), (none, none), (), loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ stmt = ir.SetItem(base, self.get(indexvar), self.get(value),
+ loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_STORE_SLICE_1(self, inst, base, start, nonevar, value, slicevar,
+ indexvar):
+ base = self.get(base)
+ start = self.get(start)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (start, none), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ stmt = ir.SetItem(base, self.get(indexvar), self.get(value),
+ loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_STORE_SLICE_2(self, inst, base, nonevar, stop, value, slicevar,
+ indexvar):
+ base = self.get(base)
+ stop = self.get(stop)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (none, stop,), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ stmt = ir.SetItem(base, self.get(indexvar), self.get(value),
+ loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_STORE_SLICE_3(self, inst, base, start, stop, value, slicevar,
+ indexvar):
+ base = self.get(base)
+ start = self.get(start)
+ stop = self.get(stop)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (start, stop), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+ stmt = ir.SetItem(base, self.get(indexvar), self.get(value),
+ loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_DELETE_SLICE_0(self, inst, base, slicevar, indexvar, nonevar):
+ base = self.get(base)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ index = ir.Expr.call(self.get(slicevar), (none, none), (), loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ stmt = ir.DelItem(base, self.get(indexvar), loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_DELETE_SLICE_1(self, inst, base, start, nonevar, slicevar, indexvar):
+ base = self.get(base)
+ start = self.get(start)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (start, none), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ stmt = ir.DelItem(base, self.get(indexvar), loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_DELETE_SLICE_2(self, inst, base, nonevar, stop, slicevar, indexvar):
+ base = self.get(base)
+ stop = self.get(stop)
+
+ nonegv = ir.Const(None, loc=self.loc)
+ self.store(value=nonegv, name=nonevar)
+ none = self.get(nonevar)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (none, stop,), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+
+ stmt = ir.DelItem(base, self.get(indexvar), loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_DELETE_SLICE_3(self, inst, base, start, stop, slicevar, indexvar):
+ base = self.get(base)
+ start = self.get(start)
+ stop = self.get(stop)
+
+ slicegv = ir.Global("slice", slice, loc=self.loc)
+ self.store(value=slicegv, name=slicevar)
+
+ index = ir.Expr.call(self.get(slicevar), (start, stop), (),
+ loc=self.loc)
+ self.store(value=index, name=indexvar)
+ stmt = ir.DelItem(base, self.get(indexvar), loc=self.loc)
+ self.current_block.append(stmt)
+
+ def _op_LOAD_FAST(self, inst, res):
+ srcname = self.code_locals[inst.arg]
+ self.store(value=self.get(srcname), name=res)
+
+ if PYVERSION in ((3, 13), ):
+ def op_LOAD_FAST(self, inst, res, as_load_deref=False):
+ if as_load_deref:
+ self.op_LOAD_DEREF(inst, res)
+ else:
+ self._op_LOAD_FAST(inst, res)
+
+ else:
+ op_LOAD_FAST = _op_LOAD_FAST
+
+ if PYVERSION in ((3, 13),):
+ def op_LOAD_FAST_LOAD_FAST(self, inst, res1, res2):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+ src1 = self.get(self.code_locals[oparg1])
+ src2 = self.get(self.code_locals[oparg2])
+ self.store(value=src1, name=res1)
+ self.store(value=src2, name=res2)
+
+ def op_STORE_FAST_LOAD_FAST(self, inst, store_value, load_res):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+
+ dstname = self.code_locals[oparg1]
+ dst_value = self.get(store_value)
+ self.store(value=dst_value, name=dstname)
+
+ src_value = self.get(self.code_locals[oparg2])
+ self.store(value=src_value, name=load_res)
+
+ def op_STORE_FAST_STORE_FAST(self, inst, value1, value2):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+
+ dstname = self.code_locals[oparg1]
+ self.store(value=self.get(value1), name=dstname)
+ dstname = self.code_locals[oparg2]
+ self.store(value=self.get(value2), name=dstname)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ op_LOAD_FAST_CHECK = op_LOAD_FAST
+
+ def op_LOAD_FAST_AND_CLEAR(self, inst, res):
+ try:
+ # try the regular LOAD_FAST logic
+ srcname = self.code_locals[inst.arg]
+ self.store(value=self.get(srcname), name=res)
+ except NotDefinedError:
+ # If the variable is not in the scope, set it to `undef`
+ undef = ir.Expr.undef(loc=self.loc)
+ self.store(undef, name=res)
+
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_STORE_FAST(self, inst, value):
+ dstname = self.code_locals[inst.arg]
+ value = self.get(value)
+ self.store(value=value, name=dstname)
+
+ def op_DELETE_FAST(self, inst):
+ dstname = self.code_locals[inst.arg]
+ self.current_block.append(ir.Del(dstname, loc=self.loc))
+
+ def op_DUP_TOPX(self, inst, orig, duped):
+ for src, dst in zip(orig, duped):
+ self.store(value=self.get(src), name=dst)
+
+ op_DUP_TOP = op_DUP_TOPX
+ op_DUP_TOP_TWO = op_DUP_TOPX
+
+ def op_STORE_ATTR(self, inst, target, value):
+ attr = self.code_names[inst.arg]
+ sa = ir.SetAttr(target=self.get(target), value=self.get(value),
+ attr=attr, loc=self.loc)
+ self.current_block.append(sa)
+
+ def op_DELETE_ATTR(self, inst, target):
+ attr = self.code_names[inst.arg]
+ sa = ir.DelAttr(target=self.get(target), attr=attr, loc=self.loc)
+ self.current_block.append(sa)
+
+ def op_LOAD_ATTR(self, inst, item, res):
+ item = self.get(item)
+ if PYVERSION in ((3, 12), (3, 13)):
+ attr = self.code_names[inst.arg >> 1]
+ elif PYVERSION in ((3, 10), (3, 11)):
+ attr = self.code_names[inst.arg]
+ else:
+ raise NotImplementedError(PYVERSION)
+ getattr = ir.Expr.getattr(item, attr, loc=self.loc)
+ self.store(getattr, res)
+
+ def op_LOAD_CONST(self, inst, res):
+ value = self.code_consts[inst.arg]
+ if isinstance(value, tuple):
+ st = []
+ for x in value:
+ nm = '$const_%s' % str(x)
+ val_const = ir.Const(x, loc=self.loc)
+ target = self.store(val_const, name=nm, redefine=True)
+ st.append(target)
+ const = ir.Expr.build_tuple(st, loc=self.loc)
+ elif isinstance(value, frozenset):
+ st = []
+ for x in value:
+ nm = '$const_%s' % str(x)
+ val_const = ir.Const(x, loc=self.loc)
+ target = self.store(val_const, name=nm, redefine=True)
+ st.append(target)
+ const = ir.Expr.build_set(st, loc=self.loc)
+ else:
+ const = ir.Const(value, loc=self.loc)
+ self.store(const, res)
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_LOAD_GLOBAL(self, inst, idx, res):
+ name = self.code_names[idx]
+ value = self.get_global_value(name)
+ gl = ir.Global(name, value, loc=self.loc)
+ self.store(gl, res)
+ elif PYVERSION in ((3, 10),):
+ def op_LOAD_GLOBAL(self, inst, res):
+ name = self.code_names[inst.arg]
+ value = self.get_global_value(name)
+ gl = ir.Global(name, value, loc=self.loc)
+ self.store(gl, res)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_COPY_FREE_VARS(self, inst):
+ pass
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_LOAD_DEREF(self, inst, res):
+ name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
+ if name in self.code_cellvars:
+ try:
+ gl = self.get(name)
+ except NotDefinedError:
+ msg = "Unsupported use of cell variable encountered"
+ raise NotImplementedError(msg)
+ elif name in self.code_freevars:
+ idx = self.code_freevars.index(name)
+ value = self.get_closure_value(idx)
+ gl = ir.FreeVar(idx, name, value, loc=self.loc)
+ self.store(gl, res)
+ elif PYVERSION in ((3, 10),):
+ def op_LOAD_DEREF(self, inst, res):
+ n_cellvars = len(self.code_cellvars)
+ if inst.arg < n_cellvars:
+ name = self.code_cellvars[inst.arg]
+ gl = self.get(name)
+ else:
+ idx = inst.arg - n_cellvars
+ name = self.code_freevars[idx]
+ value = self.get_closure_value(idx)
+ gl = ir.FreeVar(idx, name, value, loc=self.loc)
+ self.store(gl, res)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_MAKE_CELL(self, inst):
+ pass # ignored bytecode
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_STORE_DEREF(self, inst, value):
+ name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
+ value = self.get(value)
+ self.store(value=value, name=name)
+ elif PYVERSION in ((3, 10),):
+ def op_STORE_DEREF(self, inst, value):
+ n_cellvars = len(self.code_cellvars)
+ if inst.arg < n_cellvars:
+ dstname = self.code_cellvars[inst.arg]
+ else:
+ dstname = self.code_freevars[inst.arg - n_cellvars]
+ value = self.get(value)
+ self.store(value=value, name=dstname)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_SETUP_LOOP(self, inst):
+ assert self.blocks[inst.offset] is self.current_block
+ loop = ir.Loop(inst.offset, exit=(inst.next + inst.arg))
+ self.syntax_blocks.append(loop)
+
+ def op_SETUP_WITH(self, inst, contextmanager, exitfn=None):
+ assert self.blocks[inst.offset] is self.current_block
+ # Handle with
+ exitpt = inst.next + inst.arg
+
+ wth = ir.With(inst.offset, exit=exitpt)
+ self.syntax_blocks.append(wth)
+ ctxmgr = self.get(contextmanager)
+ self.current_block.append(ir.EnterWith(contextmanager=ctxmgr,
+ begin=inst.offset,
+ end=exitpt, loc=self.loc,))
+
+ # Store exit fn
+ exit_fn_obj = ir.Const(None, loc=self.loc)
+ self.store(value=exit_fn_obj, name=exitfn)
+
+ def op_BEFORE_WITH(self, inst, contextmanager, exitfn, end):
+ assert self.blocks[inst.offset] is self.current_block
+ if PYVERSION in ((3, 12), (3, 13)):
+ # Python 3.12 hack for handling nested with blocks
+ if end > self.last_active_offset:
+ # Use exception entries to figure out end of syntax block
+ end = max([ex.end for ex in self.active_exception_entries
+ if ex.target == end])
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+ # Handle with
+ wth = ir.With(inst.offset, exit=end)
+ self.syntax_blocks.append(wth)
+ ctxmgr = self.get(contextmanager)
+ self.current_block.append(ir.EnterWith(contextmanager=ctxmgr,
+ begin=inst.offset,
+ end=end, loc=self.loc,))
+
+ # Store exit function
+ exit_fn_obj = ir.Const(None, loc=self.loc)
+ self.store(value=exit_fn_obj, name=exitfn)
+
+ def op_SETUP_FINALLY(self, inst):
+ # Removed since python3.11
+ self._insert_try_block_begin()
+
+ def op_WITH_CLEANUP(self, inst):
+ "no-op"
+
+ def op_WITH_CLEANUP_START(self, inst):
+ "no-op"
+
+ def op_WITH_CLEANUP_FINISH(self, inst):
+ "no-op"
+
+ def op_END_FINALLY(self, inst):
+ "no-op"
+
+ def op_BEGIN_FINALLY(self, inst, temps):
+ # The *temps* are the exception variables
+ const_none = ir.Const(None, loc=self.loc)
+ for tmp in temps:
+ # Set to None for now
+ self.store(const_none, name=tmp)
+ self._exception_vars.add(tmp)
+
+ def op_CALL(self, inst, func, args, kw_names, res):
+ func = self.get(func)
+ args = [self.get(x) for x in args]
+ if kw_names is not None:
+ assert PYVERSION < (3, 13)
+ names = self.code_consts[kw_names]
+ kwargs = list(zip(names, args[-len(names):]))
+ args = args[:-len(names)]
+ else:
+ kwargs = ()
+ expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
+ self.store(expr, res)
+
+ if PYVERSION in ((3, 13),):
+ def op_CALL_KW(self, inst, func, args, kw_names, res):
+ func = self.get(func)
+ args = [self.get(x) for x in args]
+ consti = int(kw_names.rsplit('.', 2)[-1])
+ names = self.code_consts[consti]
+ kwargs = list(zip(names, args[-len(names):]))
+ args = args[:-len(names)]
+ expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
+ self.store(expr, res)
+ else:
+ assert PYVERSION < (3, 13)
+
+ def op_CALL_FUNCTION(self, inst, func, args, res):
+ func = self.get(func)
+ args = [self.get(x) for x in args]
+ expr = ir.Expr.call(func, args, (), loc=self.loc)
+ self.store(expr, res)
+
+ def op_CALL_FUNCTION_KW(self, inst, func, args, names, res):
+ func = self.get(func)
+ args = [self.get(x) for x in args]
+ # Find names const
+ names = self.get(names)
+ for inst in self.current_block.body:
+ if isinstance(inst, ir.Assign) and inst.target is names:
+ self.current_block.remove(inst)
+ # scan up the block looking for the values, remove them
+ # and find their name strings
+ named_items = []
+ for x in inst.value.items:
+ for y in self.current_block.body[::-1]:
+ if x == y.target:
+ self.current_block.remove(y)
+ named_items.append(y.value.value)
+ break
+ keys = named_items
+ break
+
+ nkeys = len(keys)
+ posvals = args[:-nkeys]
+ kwvals = args[-nkeys:]
+ keyvalues = list(zip(keys, kwvals))
+
+ expr = ir.Expr.call(func, posvals, keyvalues, loc=self.loc)
+ self.store(expr, res)
+
+ def op_CALL_FUNCTION_EX(self, inst, func, vararg, varkwarg, res):
+ func = self.get(func)
+ vararg = self.get(vararg)
+ if varkwarg is not None:
+ varkwarg = self.get(varkwarg)
+ expr = ir.Expr.call(
+ func, [], [], loc=self.loc, vararg=vararg, varkwarg=varkwarg
+ )
+ self.store(expr, res)
+
+ def _build_tuple_unpack(self, inst, tuples, temps, is_assign):
+ first = self.get(tuples[0])
+ if is_assign:
+ # it's assign-like, defer handling to an intrinsic that will have
+ # type information.
+ # Can deal with tuples only, i.e. y = (*x,). where x =
+ gv_name = "unpack_single_tuple"
+ gv_fn = ir.Global(gv_name, unpack_single_tuple, loc=self.loc,)
+ self.store(value=gv_fn, name=gv_name, redefine=True)
+ exc = ir.Expr.call(self.get(gv_name), args=(first,), kws=(),
+ loc=self.loc,)
+ self.store(exc, temps[0])
+ else:
+ loc = self.loc
+ for other, tmp in zip(map(self.get, tuples[1:]), temps):
+ # Emit as `first + tuple(other)`
+ gv_tuple = ir.Global(
+ name="tuple", value=tuple,
+ loc=loc,
+ )
+ tuple_var = self.store(
+ gv_tuple, "$_list_extend_gv_tuple", redefine=True,
+ )
+ tuplify_val = ir.Expr.call(
+ tuple_var, (other,), (),
+ loc=loc,
+ )
+ tuplify_var = self.store(tuplify_val, "$_tuplify",
+ redefine=True)
+ out = ir.Expr.binop(
+ fn=operator.add, lhs=first, rhs=self.get(tuplify_var.name),
+ loc=self.loc,
+ )
+ self.store(out, tmp)
+ first = self.get(tmp)
+
+ def op_BUILD_TUPLE_UNPACK_WITH_CALL(self, inst, tuples, temps, is_assign):
+ # just unpack the input tuple, call inst will be handled afterwards
+ self._build_tuple_unpack(inst, tuples, temps, is_assign)
+
+ def op_BUILD_TUPLE_UNPACK(self, inst, tuples, temps, is_assign):
+ self._build_tuple_unpack(inst, tuples, temps, is_assign)
+
+ def op_LIST_TO_TUPLE(self, inst, const_list, res):
+ expr = ir.Expr.dummy('list_to_tuple', (const_list,), loc=self.loc)
+ self.store(expr, res)
+
+ def op_BUILD_CONST_KEY_MAP(self, inst, keys, keytmps, values, res):
+ # Unpack the constant key-tuple and reused build_map which takes
+ # a sequence of (key, value) pair.
+ keyvar = self.get(keys)
+ # TODO: refactor this pattern. occurred several times.
+ for inst in self.current_block.body:
+ if isinstance(inst, ir.Assign) and inst.target is keyvar:
+ self.current_block.remove(inst)
+ # scan up the block looking for the values, remove them
+ # and find their name strings
+ named_items = []
+ for x in inst.value.items:
+ for y in self.current_block.body[::-1]:
+ if x == y.target:
+ self.current_block.remove(y)
+ named_items.append(y.value.value)
+ break
+ keytup = named_items
+ break
+ assert len(keytup) == len(values)
+ keyconsts = [ir.Const(value=x, loc=self.loc) for x in keytup]
+ for kval, tmp in zip(keyconsts, keytmps):
+ self.store(kval, tmp)
+ items = list(zip(map(self.get, keytmps), map(self.get, values)))
+
+ # sort out literal values
+ literal_items = []
+ for v in values:
+ defns = self.definitions[v]
+ if len(defns) != 1:
+ break
+ defn = defns[0]
+ if not isinstance(defn, ir.Const):
+ break
+ literal_items.append(defn.value)
+
+ def resolve_const(v):
+ defns = self.definitions[v]
+ if len(defns) != 1:
+ return _UNKNOWN_VALUE(self.get(v).name)
+ defn = defns[0]
+ if not isinstance(defn, ir.Const):
+ return _UNKNOWN_VALUE(self.get(v).name)
+ return defn.value
+
+ if len(literal_items) != len(values):
+ literal_dict = {x: resolve_const(y) for x, y in
+ zip(keytup, values)}
+ else:
+ literal_dict = {x:y for x, y in zip(keytup, literal_items)}
+
+ # to deal with things like {'a': 1, 'a': 'cat', 'b': 2, 'a': 2j}
+ # store the index of the actual used value for a given key, this is
+ # used when lowering to pull the right value out into the tuple repr
+ # of a mixed value type dictionary.
+ value_indexes = {}
+ for i, k in enumerate(keytup):
+ value_indexes[k] = i
+
+ expr = ir.Expr.build_map(items=items,
+ size=2,
+ literal_value=literal_dict,
+ value_indexes=value_indexes,
+ loc=self.loc)
+
+ self.store(expr, res)
+
+ def op_GET_ITER(self, inst, value, res):
+ expr = ir.Expr.getiter(value=self.get(value), loc=self.loc)
+ self.store(expr, res)
+
+ def op_FOR_ITER(self, inst, iterator, pair, indval, pred):
+ """
+ Assign new block other this instruction.
+ """
+ assert inst.offset in self.blocks, "FOR_ITER must be block head"
+
+ # Emit code
+ val = self.get(iterator)
+
+ pairval = ir.Expr.iternext(value=val, loc=self.loc)
+ self.store(pairval, pair)
+
+ iternext = ir.Expr.pair_first(value=self.get(pair), loc=self.loc)
+ self.store(iternext, indval)
+
+ isvalid = ir.Expr.pair_second(value=self.get(pair), loc=self.loc)
+ self.store(isvalid, pred)
+
+ # Conditional jump
+ br = ir.Branch(cond=self.get(pred), truebr=inst.next,
+ falsebr=inst.get_jump_target(),
+ loc=self.loc)
+ self.current_block.append(br)
+
+ def op_BINARY_SUBSCR(self, inst, target, index, res):
+ index = self.get(index)
+ target = self.get(target)
+ expr = ir.Expr.getitem(target, index=index, loc=self.loc)
+ self.store(expr, res)
+
+ def op_STORE_SUBSCR(self, inst, target, index, value):
+ index = self.get(index)
+ target = self.get(target)
+ value = self.get(value)
+ stmt = ir.SetItem(target=target, index=index, value=value,
+ loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_DELETE_SUBSCR(self, inst, target, index):
+ index = self.get(index)
+ target = self.get(target)
+ stmt = ir.DelItem(target=target, index=index, loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_BUILD_TUPLE(self, inst, items, res):
+ expr = ir.Expr.build_tuple(items=[self.get(x) for x in items],
+ loc=self.loc)
+ self.store(expr, res)
+
+ def op_BUILD_LIST(self, inst, items, res):
+ expr = ir.Expr.build_list(items=[self.get(x) for x in items],
+ loc=self.loc)
+ self.store(expr, res)
+
+ def op_BUILD_SET(self, inst, items, res):
+ expr = ir.Expr.build_set(items=[self.get(x) for x in items],
+ loc=self.loc)
+ self.store(expr, res)
+
+ def op_SET_UPDATE(self, inst, target, value, updatevar, res):
+ target = self.get(target)
+ value = self.get(value)
+ updateattr = ir.Expr.getattr(target, 'update', loc=self.loc)
+ self.store(value=updateattr, name=updatevar)
+ updateinst = ir.Expr.call(self.get(updatevar), (value,), (),
+ loc=self.loc)
+ self.store(value=updateinst, name=res)
+
+ def op_DICT_UPDATE(self, inst, target, value, updatevar, res):
+ target = self.get(target)
+ value = self.get(value)
+ # We generate _update_from_bytecode instead of update so we can
+ # differentiate between user .update() calls and those from the
+ # bytecode. This is then used to recombine dictionaries in peephole
+ # optimizations. See the dicussion in this PR about why:
+ # https://github.com/numba/numba/pull/7964/files#r868229306
+ updateattr = ir.Expr.getattr(
+ target, '_update_from_bytecode', loc=self.loc
+ )
+ self.store(value=updateattr, name=updatevar)
+ updateinst = ir.Expr.call(self.get(updatevar), (value,), (),
+ loc=self.loc)
+ self.store(value=updateinst, name=res)
+
+ def op_BUILD_MAP(self, inst, items, size, res):
+ got_items = [(self.get(k), self.get(v)) for k, v in items]
+
+ # sort out literal values, this is a bit contrived but is to handle
+ # situations like `{1: 10, 1: 10}` where the size of the literal dict
+ # is smaller than the definition
+ def get_literals(target):
+ literal_items = []
+ values = [self.get(v.name) for v in target]
+ for v in values:
+ defns = self.definitions[v.name]
+ if len(defns) != 1:
+ break
+ defn = defns[0]
+ if not isinstance(defn, ir.Const):
+ break
+ literal_items.append(defn.value)
+ return literal_items
+
+ literal_keys = get_literals(x[0] for x in got_items)
+ literal_values = get_literals(x[1] for x in got_items)
+
+ has_literal_keys = len(literal_keys) == len(got_items)
+ has_literal_values = len(literal_values) == len(got_items)
+
+ value_indexes = {}
+ if not has_literal_keys and not has_literal_values:
+ literal_dict = None
+ elif has_literal_keys and not has_literal_values:
+ literal_dict = {x: _UNKNOWN_VALUE(y[1]) for x, y in
+ zip(literal_keys, got_items)}
+ for i, k in enumerate(literal_keys):
+ value_indexes[k] = i
+ else:
+ literal_dict = {x: y for x, y in zip(literal_keys, literal_values)}
+ for i, k in enumerate(literal_keys):
+ value_indexes[k] = i
+
+ expr = ir.Expr.build_map(items=got_items, size=size,
+ literal_value=literal_dict,
+ value_indexes=value_indexes,
+ loc=self.loc)
+ self.store(expr, res)
+
+ def op_STORE_MAP(self, inst, dct, key, value):
+ stmt = ir.StoreMap(dct=self.get(dct), key=self.get(key),
+ value=self.get(value), loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_UNARY_NEGATIVE(self, inst, value, res):
+ value = self.get(value)
+ expr = ir.Expr.unary('-', value=value, loc=self.loc)
+ return self.store(expr, res)
+
+ def op_UNARY_POSITIVE(self, inst, value, res):
+ value = self.get(value)
+ expr = ir.Expr.unary('+', value=value, loc=self.loc)
+ return self.store(expr, res)
+
+ def op_UNARY_INVERT(self, inst, value, res):
+ value = self.get(value)
+ expr = ir.Expr.unary('~', value=value, loc=self.loc)
+ return self.store(expr, res)
+
+ def op_UNARY_NOT(self, inst, value, res):
+ value = self.get(value)
+ expr = ir.Expr.unary('not', value=value, loc=self.loc)
+ return self.store(expr, res)
+
+ def _binop(self, op, lhs, rhs, res):
+ op = BINOPS_TO_OPERATORS[op]
+ lhs = self.get(lhs)
+ rhs = self.get(rhs)
+ expr = ir.Expr.binop(op, lhs=lhs, rhs=rhs, loc=self.loc)
+ self.store(expr, res)
+
+ def _inplace_binop(self, op, lhs, rhs, res):
+ immuop = BINOPS_TO_OPERATORS[op]
+ op = INPLACE_BINOPS_TO_OPERATORS[op + '=']
+ lhs = self.get(lhs)
+ rhs = self.get(rhs)
+ expr = ir.Expr.inplace_binop(op, immuop, lhs=lhs, rhs=rhs,
+ loc=self.loc)
+ self.store(expr, res)
+
+ def op_BINARY_OP(self, inst, op, lhs, rhs, res):
+ if "=" in op:
+ self._inplace_binop(op[:-1], lhs, rhs, res)
+ else:
+ self._binop(op, lhs, rhs, res)
+
+ def op_BINARY_ADD(self, inst, lhs, rhs, res):
+ self._binop('+', lhs, rhs, res)
+
+ def op_BINARY_SUBTRACT(self, inst, lhs, rhs, res):
+ self._binop('-', lhs, rhs, res)
+
+ def op_BINARY_MULTIPLY(self, inst, lhs, rhs, res):
+ self._binop('*', lhs, rhs, res)
+
+ def op_BINARY_DIVIDE(self, inst, lhs, rhs, res):
+ self._binop('/?', lhs, rhs, res)
+
+ def op_BINARY_TRUE_DIVIDE(self, inst, lhs, rhs, res):
+ self._binop('/', lhs, rhs, res)
+
+ def op_BINARY_FLOOR_DIVIDE(self, inst, lhs, rhs, res):
+ self._binop('//', lhs, rhs, res)
+
+ def op_BINARY_MODULO(self, inst, lhs, rhs, res):
+ self._binop('%', lhs, rhs, res)
+
+ def op_BINARY_POWER(self, inst, lhs, rhs, res):
+ self._binop('**', lhs, rhs, res)
+
+ def op_BINARY_MATRIX_MULTIPLY(self, inst, lhs, rhs, res):
+ self._binop('@', lhs, rhs, res)
+
+ def op_BINARY_LSHIFT(self, inst, lhs, rhs, res):
+ self._binop('<<', lhs, rhs, res)
+
+ def op_BINARY_RSHIFT(self, inst, lhs, rhs, res):
+ self._binop('>>', lhs, rhs, res)
+
+ def op_BINARY_AND(self, inst, lhs, rhs, res):
+ self._binop('&', lhs, rhs, res)
+
+ def op_BINARY_OR(self, inst, lhs, rhs, res):
+ self._binop('|', lhs, rhs, res)
+
+ def op_BINARY_XOR(self, inst, lhs, rhs, res):
+ self._binop('^', lhs, rhs, res)
+
+ def op_INPLACE_ADD(self, inst, lhs, rhs, res):
+ self._inplace_binop('+', lhs, rhs, res)
+
+ def op_INPLACE_SUBTRACT(self, inst, lhs, rhs, res):
+ self._inplace_binop('-', lhs, rhs, res)
+
+ def op_INPLACE_MULTIPLY(self, inst, lhs, rhs, res):
+ self._inplace_binop('*', lhs, rhs, res)
+
+ def op_INPLACE_DIVIDE(self, inst, lhs, rhs, res):
+ self._inplace_binop('/?', lhs, rhs, res)
+
+ def op_INPLACE_TRUE_DIVIDE(self, inst, lhs, rhs, res):
+ self._inplace_binop('/', lhs, rhs, res)
+
+ def op_INPLACE_FLOOR_DIVIDE(self, inst, lhs, rhs, res):
+ self._inplace_binop('//', lhs, rhs, res)
+
+ def op_INPLACE_MODULO(self, inst, lhs, rhs, res):
+ self._inplace_binop('%', lhs, rhs, res)
+
+ def op_INPLACE_POWER(self, inst, lhs, rhs, res):
+ self._inplace_binop('**', lhs, rhs, res)
+
+ def op_INPLACE_MATRIX_MULTIPLY(self, inst, lhs, rhs, res):
+ self._inplace_binop('@', lhs, rhs, res)
+
+ def op_INPLACE_LSHIFT(self, inst, lhs, rhs, res):
+ self._inplace_binop('<<', lhs, rhs, res)
+
+ def op_INPLACE_RSHIFT(self, inst, lhs, rhs, res):
+ self._inplace_binop('>>', lhs, rhs, res)
+
+ def op_INPLACE_AND(self, inst, lhs, rhs, res):
+ self._inplace_binop('&', lhs, rhs, res)
+
+ def op_INPLACE_OR(self, inst, lhs, rhs, res):
+ self._inplace_binop('|', lhs, rhs, res)
+
+ def op_INPLACE_XOR(self, inst, lhs, rhs, res):
+ self._inplace_binop('^', lhs, rhs, res)
+
+ def op_JUMP_ABSOLUTE(self, inst):
+ jmp = ir.Jump(inst.get_jump_target(), loc=self.loc)
+ self.current_block.append(jmp)
+
+ def op_JUMP_FORWARD(self, inst):
+ jmp = ir.Jump(inst.get_jump_target(), loc=self.loc)
+ self.current_block.append(jmp)
+
+ def op_JUMP_BACKWARD(self, inst):
+ jmp = ir.Jump(inst.get_jump_target(), loc=self.loc)
+ self.current_block.append(jmp)
+
+ op_JUMP_BACKWARD_NO_INTERRUPT = op_JUMP_BACKWARD
+
+ def op_POP_BLOCK(self, inst, kind=None):
+ if kind is None:
+ self.syntax_blocks.pop()
+ elif kind == 'with':
+ d = ir.PopBlock(loc=self.loc)
+ self.current_block.append(d)
+ elif kind == 'try':
+ self._insert_try_block_end()
+
+ def op_RETURN_VALUE(self, inst, retval, castval):
+ self.store(ir.Expr.cast(self.get(retval), loc=self.loc), castval)
+ ret = ir.Return(self.get(castval), loc=self.loc)
+ self.current_block.append(ret)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_RETURN_CONST(self, inst, retval, castval):
+ value = self.code_consts[inst.arg]
+ const = ir.Const(value, loc=self.loc)
+ self.store(const, retval)
+ self.store(ir.Expr.cast(self.get(retval), loc=self.loc), castval)
+ ret = ir.Return(self.get(castval), loc=self.loc)
+ self.current_block.append(ret)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 13),):
+ def op_TO_BOOL(self, inst, val, res):
+ self.store(self.get(val), res) # TODO: just a lazy hack
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_COMPARE_OP(self, inst, lhs, rhs, res):
+ if PYVERSION in ((3, 13),):
+ op = dis.cmp_op[inst.arg >> 5]
+ # TODO: fifth lowest bit now indicates a forced version to bool.
+ elif PYVERSION in ((3, 12),):
+ op = dis.cmp_op[inst.arg >> 4]
+ elif PYVERSION in ((3, 10), (3, 11)):
+ op = dis.cmp_op[inst.arg]
+ else:
+ raise NotImplementedError(PYVERSION)
+ if op == 'in' or op == 'not in':
+ lhs, rhs = rhs, lhs
+
+ if op == 'not in':
+ self._binop('in', lhs, rhs, res)
+ tmp = self.get(res)
+ out = ir.Expr.unary('not', value=tmp, loc=self.loc)
+ self.store(out, res)
+ elif op == 'exception match':
+ gv_fn = ir.Global(
+ "exception_match", eh.exception_match, loc=self.loc,
+ )
+ exc_match_name = '$exc_match'
+ self.store(value=gv_fn, name=exc_match_name, redefine=True)
+ lhs = self.get(lhs)
+ rhs = self.get(rhs)
+ exc = ir.Expr.call(
+ self.get(exc_match_name), args=(lhs, rhs), kws=(), loc=self.loc,
+ )
+ self.store(exc, res)
+ else:
+ self._binop(op, lhs, rhs, res)
+
+ def op_IS_OP(self, inst, lhs, rhs, res):
+ # invert if op case is 1
+ op = 'is not' if inst.arg == 1 else 'is'
+ self._binop(op, lhs, rhs, res)
+
+ def op_CONTAINS_OP(self, inst, lhs, rhs, res):
+ lhs, rhs = rhs, lhs
+ self._binop('in', lhs, rhs, res)
+ # invert if op case is 1
+ if inst.arg == 1:
+ tmp = self.get(res)
+ out = ir.Expr.unary('not', value=tmp, loc=self.loc)
+ self.store(out, res)
+
+ def op_BREAK_LOOP(self, inst, end=None):
+ if end is None:
+ loop = self.syntax_blocks[-1]
+ assert isinstance(loop, ir.Loop)
+ end = loop.exit
+ jmp = ir.Jump(target=end, loc=self.loc)
+ self.current_block.append(jmp)
+
+ def _op_JUMP_IF(self, inst, pred, iftrue):
+ brs = {
+ True: inst.get_jump_target(),
+ False: inst.next,
+ }
+ truebr = brs[iftrue]
+ falsebr = brs[not iftrue]
+
+ name = "bool%s" % (inst.offset)
+ gv_fn = ir.Global("bool", bool, loc=self.loc)
+ self.store(value=gv_fn, name=name)
+
+ callres = ir.Expr.call(self.get(name), (self.get(pred),), (),
+ loc=self.loc)
+
+ pname = "$%spred" % (inst.offset)
+ predicate = self.store(value=callres, name=pname)
+ bra = ir.Branch(cond=predicate, truebr=truebr, falsebr=falsebr,
+ loc=self.loc)
+ self.current_block.append(bra)
+
+ def op_JUMP_IF_FALSE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=False)
+
+ def op_JUMP_IF_TRUE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=True)
+
+ def _jump_if_none(self, inst, pred, iftrue):
+ # branch pruning assumes true falls through and false is jump
+ truebr = inst.next
+ falsebr = inst.get_jump_target()
+
+ # this seems strange
+ if not iftrue:
+ op = BINOPS_TO_OPERATORS["is"]
+ else:
+ op = BINOPS_TO_OPERATORS["is not"]
+
+ rhs = self.store(value=ir.Const(None, loc=self.loc),
+ name=f"$constNone{inst.offset}")
+ lhs = self.get(pred)
+ isnone = ir.Expr.binop(op, lhs=lhs, rhs=rhs, loc=self.loc)
+
+ maybeNone = f"$maybeNone{inst.offset}"
+ self.store(value=isnone, name=maybeNone)
+
+ name = f"$bool{inst.offset}"
+ gv_fn = ir.Global("bool", bool, loc=self.loc)
+ self.store(value=gv_fn, name=name)
+
+ callres = ir.Expr.call(self.get(name), (self.get(maybeNone),), (),
+ loc=self.loc)
+
+ pname = f"$pred{inst.offset}"
+ predicate = self.store(value=callres, name=pname)
+ branch = ir.Branch(cond=predicate,
+ truebr=truebr,
+ falsebr=falsebr,
+ loc=self.loc)
+ self.current_block.append(branch)
+
+ def op_POP_JUMP_FORWARD_IF_NONE(self, inst, pred):
+ self._jump_if_none(inst, pred, True)
+
+ def op_POP_JUMP_FORWARD_IF_NOT_NONE(self, inst, pred):
+ self._jump_if_none(inst, pred, False)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_POP_JUMP_IF_NONE(self, inst, pred):
+ self._jump_if_none(inst, pred, True)
+
+ def op_POP_JUMP_IF_NOT_NONE(self, inst, pred):
+ self._jump_if_none(inst, pred, False)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_POP_JUMP_BACKWARD_IF_NONE(self, inst, pred):
+ self._jump_if_none(inst, pred, True)
+
+ def op_POP_JUMP_BACKWARD_IF_NOT_NONE(self, inst, pred):
+ self._jump_if_none(inst, pred, False)
+
+ def op_POP_JUMP_FORWARD_IF_FALSE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=False)
+
+ def op_POP_JUMP_FORWARD_IF_TRUE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=True)
+
+ def op_POP_JUMP_BACKWARD_IF_FALSE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=False)
+
+ def op_POP_JUMP_BACKWARD_IF_TRUE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=True)
+
+ def op_POP_JUMP_IF_FALSE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=False)
+
+ def op_POP_JUMP_IF_TRUE(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=True)
+
+ def op_JUMP_IF_FALSE_OR_POP(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=False)
+
+ def op_JUMP_IF_TRUE_OR_POP(self, inst, pred):
+ self._op_JUMP_IF(inst, pred=pred, iftrue=True)
+
+ def op_CHECK_EXC_MATCH(self, inst, pred, tos, tos1):
+ gv_fn = ir.Global(
+ "exception_match", eh.exception_match, loc=self.loc,
+ )
+ exc_match_name = '$exc_match'
+ self.store(value=gv_fn, name=exc_match_name, redefine=True)
+ lhs = self.get(tos1)
+ rhs = self.get(tos)
+ exc = ir.Expr.call(
+ self.get(exc_match_name), args=(lhs, rhs), kws=(), loc=self.loc,
+ )
+ self.store(exc, pred)
+
+ def op_JUMP_IF_NOT_EXC_MATCH(self, inst, pred, tos, tos1):
+ truebr = inst.next
+ falsebr = inst.get_jump_target()
+ gv_fn = ir.Global(
+ "exception_match", eh.exception_match, loc=self.loc,
+ )
+ exc_match_name = '$exc_match'
+ self.store(value=gv_fn, name=exc_match_name, redefine=True)
+ lhs = self.get(tos1)
+ rhs = self.get(tos)
+ exc = ir.Expr.call(
+ self.get(exc_match_name), args=(lhs, rhs), kws=(), loc=self.loc,
+ )
+ predicate = self.store(exc, pred)
+ bra = ir.Branch(cond=predicate, truebr=truebr, falsebr=falsebr,
+ loc=self.loc)
+ self.current_block.append(bra)
+
+ def op_RERAISE(self, inst, exc):
+ tryblk = self.dfainfo.active_try_block
+ if tryblk is not None:
+ stmt = ir.TryRaise(exception=None, loc=self.loc)
+ self.current_block.append(stmt)
+ self._insert_try_block_end()
+ self.current_block.append(ir.Jump(tryblk['end'], loc=self.loc))
+ else:
+ # Numba can't handle this case and it's caught else where, this is a
+ # runtime guard in case this is reached by unknown means.
+ msg = (f"Unreachable condition reached (op code RERAISE executed)"
+ f"{error_extras['reportable']}")
+ stmt = ir.StaticRaise(AssertionError, (msg,), self.loc)
+ self.current_block.append(stmt)
+
+ def op_RAISE_VARARGS(self, inst, exc):
+ if exc is not None:
+ exc = self.get(exc)
+ tryblk = self.dfainfo.active_try_block
+ if tryblk is not None:
+ # In a try block
+ stmt = ir.TryRaise(exception=exc, loc=self.loc)
+ self.current_block.append(stmt)
+ self._insert_try_block_end()
+ self.current_block.append(ir.Jump(tryblk['end'], loc=self.loc))
+ else:
+ # Not in a try block
+ stmt = ir.Raise(exception=exc, loc=self.loc)
+ self.current_block.append(stmt)
+
+ def op_YIELD_VALUE(self, inst, value, res):
+ # initialize index to None. it's being set later in post-processing
+ index = None
+ inst = ir.Yield(value=self.get(value), index=index, loc=self.loc)
+ return self.store(inst, res)
+
+ def op_MAKE_FUNCTION(self, inst, name, code, closure, annotations,
+ kwdefaults, defaults, res):
+ # annotations are ignored by numba but useful for static analysis
+ # re. https://github.com/numba/numba/issues/7269
+ if kwdefaults is not None:
+ msg = "op_MAKE_FUNCTION with kwdefaults is not implemented"
+ raise NotImplementedError(msg)
+ if defaults:
+ if isinstance(defaults, tuple):
+ defaults = tuple([self.get(name) for name in defaults])
+ else:
+ defaults = self.get(defaults)
+
+ assume_code_const = self.definitions[code][0]
+ if not isinstance(assume_code_const, ir.Const):
+ msg = (
+ "Unsupported use of closure. "
+ "Probably caused by complex control-flow constructs; "
+ "e.g. try-except"
+ )
+ raise errors.UnsupportedBytecodeError(msg, loc=self.loc)
+ fcode = assume_code_const.value
+ if name:
+ name = self.get(name)
+ if closure:
+ closure = self.get(closure)
+ expr = ir.Expr.make_function(name, fcode, closure, defaults, self.loc)
+ self.store(expr, res)
+
+ def op_MAKE_CLOSURE(self, inst, name, code, closure, annotations,
+ kwdefaults, defaults, res):
+ self.op_MAKE_FUNCTION(inst, name, code, closure, annotations,
+ kwdefaults, defaults, res)
+
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
+ def op_LOAD_CLOSURE(self, inst, res):
+ name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
+ if name in self.code_cellvars:
+ try:
+ gl = self.get(name)
+ except NotDefinedError:
+ msg = "Unsupported use of cell variable encountered"
+ raise NotImplementedError(msg)
+ elif name in self.code_freevars:
+ idx = self.code_freevars.index(name)
+ value = self.get_closure_value(idx)
+ gl = ir.FreeVar(idx, name, value, loc=self.loc)
+ else:
+ assert 0, "unreachable"
+ self.store(gl, res)
+
+ elif PYVERSION in ((3, 10),):
+ def op_LOAD_CLOSURE(self, inst, res):
+ n_cellvars = len(self.code_cellvars)
+ if inst.arg < n_cellvars:
+ name = self.code_cellvars[inst.arg]
+ try:
+ gl = self.get(name)
+ except NotDefinedError:
+ msg = "Unsupported use of cell variable encountered"
+ raise NotImplementedError(msg)
+ else:
+ idx = inst.arg - n_cellvars
+ name = self.code_freevars[idx]
+ value = self.get_closure_value(idx)
+ gl = ir.FreeVar(idx, name, value, loc=self.loc)
+ self.store(gl, res)
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ def op_LIST_APPEND(self, inst, target, value, appendvar, res):
+ target = self.get(target)
+ value = self.get(value)
+ appendattr = ir.Expr.getattr(target, 'append', loc=self.loc)
+ self.store(value=appendattr, name=appendvar)
+ appendinst = ir.Expr.call(self.get(appendvar), (value,), (),
+ loc=self.loc)
+ self.store(value=appendinst, name=res)
+
+ def op_LIST_EXTEND(self, inst, target, value, extendvar, res):
+ target = self.get(target)
+ value = self.get(value)
+ # If the statements between the current instruction and the target
+ # are N * consts followed by build_tuple AND the target has no items,
+ # it's a situation where a list is being statically initialised, rewrite
+ # the build_tuple as a build_list, drop the extend, and wire up the
+ # target as the result from the build_tuple that's been rewritten.
+
+ # See if this is the first statement in a block, if so its probably from
+ # control flow in a tuple unpack like:
+ # `(*(1, (2,) if predicate else (3,)))`
+ # this cannot be handled as present so raise
+ msg = ("An unsupported bytecode sequence has been encountered: "
+ "op_LIST_EXTEND at the start of a block.\n\nThis could be "
+ "due to the use of a branch in a tuple unpacking statement.")
+ if not self.current_block.body:
+ raise errors.UnsupportedBytecodeError(msg)
+
+ # is last emitted statement a build_tuple?
+ stmt = self.current_block.body[-1]
+ ok = isinstance(stmt.value, ir.Expr) and stmt.value.op == "build_tuple"
+ # check statements from self.current_block.body[-1] through to target,
+ # make sure they are consts
+ build_empty_list = None
+ if ok:
+ for stmt in reversed(self.current_block.body[:-1]):
+ if not isinstance(stmt, ir.Assign):
+ ok = False
+ break
+ # if its not a const, it needs to be the `build_list` for the
+ # target, else it's something else we don't know about so just
+ # bail
+ if isinstance(stmt.value, ir.Const):
+ continue
+
+ # it's not a const, check for target
+ elif isinstance(stmt.value, ir.Expr) and stmt.target == target:
+ build_empty_list = stmt
+ # it's only ok to do this if the target has no initializer
+ # already
+ ok = not stmt.value.items
+ break
+ else:
+ ok = False
+ break
+ if ok and build_empty_list is None:
+ raise errors.UnsupportedBytecodeError(msg)
+ if ok:
+ stmts = self.current_block.body
+ build_tuple_asgn = self.current_block.body[-1]
+ # move build list to last issued statement
+ stmts.append(stmts.pop(stmts.index(build_empty_list)))
+ # fix the build list
+ build_tuple = build_tuple_asgn.value
+ build_list = build_empty_list.value
+ build_list.items = build_tuple.items
+ else:
+ # it's just a list extend with no static init, let it be
+ extendattr = ir.Expr.getattr(target, 'extend', loc=self.loc)
+ self.store(value=extendattr, name=extendvar)
+ extendinst = ir.Expr.call(self.get(extendvar), (value,), (),
+ loc=self.loc)
+ self.store(value=extendinst, name=res)
+
+ def op_MAP_ADD(self, inst, target, key, value, setitemvar, res):
+ target = self.get(target)
+ key = self.get(key)
+ value = self.get(value)
+ setitemattr = ir.Expr.getattr(target, '__setitem__', loc=self.loc)
+ self.store(value=setitemattr, name=setitemvar)
+ appendinst = ir.Expr.call(self.get(setitemvar), (key, value,), (),
+ loc=self.loc)
+ self.store(value=appendinst, name=res)
+
+ def op_LOAD_ASSERTION_ERROR(self, inst, res):
+ gv_fn = ir.Global("AssertionError", AssertionError, loc=self.loc)
+ self.store(value=gv_fn, name=res)
+
+ # NOTE: The LOAD_METHOD opcode is implemented as a LOAD_ATTR for ease,
+ # however this means a new object (the bound-method instance) could be
+ # created. Conversely, using a pure LOAD_METHOD no intermediary is present
+ # and it is essentially like a pointer grab and forward to CALL_METHOD. The
+ # net outcome is that the implementation in Numba produces the same result,
+ # but in object mode it may be that it runs more slowly than it would if
+ # run in CPython.
+
+ def op_LOAD_METHOD(self, *args, **kws):
+ self.op_LOAD_ATTR(*args, **kws)
+
+ def op_CALL_METHOD(self, *args, **kws):
+ self.op_CALL_FUNCTION(*args, **kws)
+
+ if PYVERSION in ((3, 12), (3, 13)):
+ def op_CALL_INTRINSIC_1(self, inst, operand, **kwargs):
+ if operand == ci1op.INTRINSIC_STOPITERATION_ERROR:
+ stmt = ir.StaticRaise(INTRINSIC_STOPITERATION_ERROR, (),
+ self.loc)
+ self.current_block.append(stmt)
+ return
+ elif operand == ci1op.UNARY_POSITIVE:
+ self.op_UNARY_POSITIVE(inst, **kwargs)
+ return
+ elif operand == ci1op.INTRINSIC_LIST_TO_TUPLE:
+ self.op_LIST_TO_TUPLE(inst, **kwargs)
+ return
+ else:
+ raise NotImplementedError(operand)
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+
+if PYVERSION in ((3, 12), (3, 13)):
+ class INTRINSIC_STOPITERATION_ERROR(AssertionError):
+ pass
+elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+else:
+ raise NotImplementedError(PYVERSION)
diff --git a/venv/lib/python3.10/site-packages/numba/core/intrinsics.py b/venv/lib/python3.10/site-packages/numba/core/intrinsics.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e85bb35400e7770c1746fb375afc248cb0fe35d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/intrinsics.py
@@ -0,0 +1,101 @@
+"""
+LLVM pass that converts intrinsic into other math calls
+"""
+
+from llvmlite import ir
+
+
+class _DivmodFixer(ir.Visitor):
+ def visit_Instruction(self, instr):
+ if instr.type == ir.IntType(64):
+ if instr.opname in ['srem', 'urem', 'sdiv', 'udiv']:
+ name = 'numba_{op}'.format(op=instr.opname)
+ fn = self.module.globals.get(name)
+ # Declare the function if it doesn't already exist
+ if fn is None:
+ opty = instr.type
+ sdivfnty = ir.FunctionType(opty, [opty, opty])
+ fn = ir.Function(self.module, sdivfnty, name=name)
+ # Replace the operation with a call to the builtin
+ repl = ir.CallInstr(parent=instr.parent, func=fn,
+ args=instr.operands, name=instr.name)
+ instr.parent.replace(instr, repl)
+
+
+def fix_divmod(mod):
+ """Replace division and reminder instructions to builtins calls
+ """
+ _DivmodFixer().visit(mod)
+
+
+INTR_TO_CMATH = {
+ "llvm.pow.f32": "powf",
+ "llvm.pow.f64": "pow",
+
+ "llvm.sin.f32": "sinf",
+ "llvm.sin.f64": "sin",
+
+ "llvm.cos.f32": "cosf",
+ "llvm.cos.f64": "cos",
+
+ "llvm.sqrt.f32": "sqrtf",
+ "llvm.sqrt.f64": "sqrt",
+
+ "llvm.exp.f32": "expf",
+ "llvm.exp.f64": "exp",
+
+ "llvm.log.f32": "logf",
+ "llvm.log.f64": "log",
+
+ "llvm.log10.f32": "log10f",
+ "llvm.log10.f64": "log10",
+
+ "llvm.fabs.f32": "fabsf",
+ "llvm.fabs.f64": "fabs",
+
+ "llvm.floor.f32": "floorf",
+ "llvm.floor.f64": "floor",
+
+ "llvm.ceil.f32": "ceilf",
+ "llvm.ceil.f64": "ceil",
+
+ "llvm.trunc.f32": "truncf",
+ "llvm.trunc.f64": "trunc",
+}
+
+OTHER_CMATHS = '''
+tan
+tanf
+sinh
+sinhf
+cosh
+coshf
+tanh
+tanhf
+asin
+asinf
+acos
+acosf
+atan
+atanf
+atan2
+atan2f
+asinh
+asinhf
+acosh
+acoshf
+atanh
+atanhf
+expm1
+expm1f
+log1p
+log1pf
+log10
+log10f
+fmod
+fmodf
+round
+roundf
+'''.split()
+
+INTR_MATH = frozenset(INTR_TO_CMATH.values()) | frozenset(OTHER_CMATHS)
diff --git a/venv/lib/python3.10/site-packages/numba/core/ir.py b/venv/lib/python3.10/site-packages/numba/core/ir.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7efe4017e83f3de6e8cb83a969bb0d1754c6dd8
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/ir.py
@@ -0,0 +1,1702 @@
+from collections import defaultdict
+import copy
+import itertools
+import os
+import linecache
+import pprint
+import re
+import sys
+import operator
+from types import FunctionType, BuiltinFunctionType
+from functools import total_ordering
+from io import StringIO
+
+from numba.core import errors, config
+from numba.core.utils import (BINOPS_TO_OPERATORS, INPLACE_BINOPS_TO_OPERATORS,
+ UNARY_BUITINS_TO_OPERATORS, OPERATORS_TO_BUILTINS)
+from numba.core.errors import (NotDefinedError, RedefinedError,
+ VerificationError, ConstantInferenceError)
+from numba.core import consts
+
+# terminal color markup
+_termcolor = errors.termcolor()
+
+
+class Loc(object):
+ """Source location
+
+ """
+ _defmatcher = re.compile(r'def\s+(\w+)')
+
+ def __init__(self, filename, line, col=None, maybe_decorator=False):
+ """ Arguments:
+ filename - name of the file
+ line - line in file
+ col - column
+ maybe_decorator - Set to True if location is likely a jit decorator
+ """
+ self.filename = filename
+ self.line = line
+ self.col = col
+ self.lines = None # the source lines from the linecache
+ self.maybe_decorator = maybe_decorator
+
+ def __eq__(self, other):
+ # equivalence is solely based on filename, line and col
+ if type(self) is not type(other): return False
+ if self.filename != other.filename: return False
+ if self.line != other.line: return False
+ if self.col != other.col: return False
+ return True
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+ @classmethod
+ def from_function_id(cls, func_id):
+ return cls(func_id.filename, func_id.firstlineno, maybe_decorator=True)
+
+ def __repr__(self):
+ return "Loc(filename=%s, line=%s, col=%s)" % (self.filename,
+ self.line, self.col)
+
+ def __str__(self):
+ if self.col is not None:
+ return "%s (%s:%s)" % (self.filename, self.line, self.col)
+ else:
+ return "%s (%s)" % (self.filename, self.line)
+
+ def _find_definition(self):
+ # try and find a def, go backwards from error line
+ fn_name = None
+ lines = self.get_lines()
+ for x in reversed(lines[:self.line - 1]):
+ # the strip and startswith is to handle user code with commented out
+ # 'def' or use of 'def' in a docstring.
+ if x.strip().startswith('def '):
+ fn_name = x
+ break
+
+ return fn_name
+
+ def _raw_function_name(self):
+ defn = self._find_definition()
+ if defn:
+ m = self._defmatcher.match(defn.strip())
+ if m:
+ return m.groups()[0]
+ # Probably exec() or REPL.
+ return None
+
+ def get_lines(self):
+ if self.lines is None:
+ path = self._get_path()
+ # Avoid reading from dynamic string. They are most likely
+ # overridden. Problem started with Python 3.13. "" seems
+ # to be something from multiprocessing.
+ lns = [] if path == "" else linecache.getlines(path)
+ self.lines = lns
+ return self.lines
+
+ def _get_path(self):
+ path = None
+ try:
+ # Try to get a relative path
+ # ipython/jupyter input just returns as self.filename
+ path = os.path.relpath(self.filename)
+ except ValueError:
+ # Fallback to absolute path if error occurred in getting the
+ # relative path.
+ # This may happen on windows if the drive is different
+ path = os.path.abspath(self.filename)
+ return path
+
+
+ def strformat(self, nlines_up=2):
+
+ lines = self.get_lines()
+
+ use_line = self.line
+
+ if self.maybe_decorator:
+ # try and sort out a better `loc`, if it's suspected that this loc
+ # points at a jit decorator by virtue of
+ # `__code__.co_firstlineno`
+
+ # get lines, add a dummy entry at the start as lines count from
+ # 1 but list index counts from 0
+ tmplines = [''] + lines
+
+ if lines and use_line and 'def ' not in tmplines[use_line]:
+ # look forward 10 lines, unlikely anyone managed to stretch
+ # a jit call declaration over >10 lines?!
+ min_line = max(0, use_line)
+ max_line = use_line + 10
+ selected = tmplines[min_line : max_line]
+ index = 0
+ for idx, x in enumerate(selected):
+ if 'def ' in x:
+ index = idx
+ break
+ use_line = use_line + index
+
+
+ ret = [] # accumulates output
+ if lines and use_line > 0:
+
+ def count_spaces(string):
+ spaces = 0
+ for x in itertools.takewhile(str.isspace, str(string)):
+ spaces += 1
+ return spaces
+
+ # A few places in the code still use no `loc` or default to line 1
+ # this is often in places where exceptions are used for the purposes
+ # of flow control. As a result max is in use to prevent slice from
+ # `[negative: positive]`
+ selected = lines[max(0, use_line - nlines_up):use_line]
+
+ # see if selected contains a definition
+ def_found = False
+ for x in selected:
+ if 'def ' in x:
+ def_found = True
+
+ # no definition found, try and find one
+ if not def_found:
+ # try and find a def, go backwards from error line
+ fn_name = None
+ for x in reversed(lines[:use_line - 1]):
+ if 'def ' in x:
+ fn_name = x
+ break
+ if fn_name:
+ ret.append(fn_name)
+ spaces = count_spaces(x)
+ ret.append(' '*(4 + spaces) + '\n')
+
+ if selected:
+ ret.extend(selected[:-1])
+ ret.append(_termcolor.highlight(selected[-1]))
+
+ # point at the problem with a caret
+ spaces = count_spaces(selected[-1])
+ ret.append(' '*(spaces) + _termcolor.indicate("^"))
+
+ # if in the REPL source may not be available
+ if not ret:
+ if not lines:
+ ret = ""
+ elif use_line <= 0:
+ ret = ""
+
+
+ err = _termcolor.filename('\nFile "%s", line %d:')+'\n%s'
+ tmp = err % (self._get_path(), use_line, _termcolor.code(''.join(ret)))
+ return tmp
+
+ def with_lineno(self, line, col=None):
+ """
+ Return a new Loc with this line number.
+ """
+ return type(self)(self.filename, line, col)
+
+ def short(self):
+ """
+ Returns a short string
+ """
+ shortfilename = os.path.basename(self.filename)
+ return "%s:%s" % (shortfilename, self.line)
+
+
+# Used for annotating errors when source location is unknown.
+unknown_loc = Loc("unknown location", 0, 0)
+
+
+@total_ordering
+class SlotEqualityCheckMixin(object):
+ # some ir nodes are __dict__ free using __slots__ instead, this mixin
+ # should not trigger the unintended creation of __dict__.
+ __slots__ = tuple()
+
+ def __eq__(self, other):
+ if type(self) is type(other):
+ for name in self.__slots__:
+ if getattr(self, name) != getattr(other, name):
+ return False
+ else:
+ return True
+ return False
+
+ def __le__(self, other):
+ return str(self) <= str(other)
+
+ def __hash__(self):
+ return id(self)
+
+
+@total_ordering
+class EqualityCheckMixin(object):
+ """ Mixin for basic equality checking """
+
+ def __eq__(self, other):
+ if type(self) is type(other):
+ def fixup(adict):
+ bad = ('loc', 'scope')
+ d = dict(adict)
+ for x in bad:
+ d.pop(x, None)
+ return d
+ d1 = fixup(self.__dict__)
+ d2 = fixup(other.__dict__)
+ if d1 == d2:
+ return True
+ return False
+
+ def __le__(self, other):
+ return str(self) < str(other)
+
+ def __hash__(self):
+ return id(self)
+
+
+class VarMap(object):
+ def __init__(self):
+ self._con = {}
+
+ def define(self, name, var):
+ if name in self._con:
+ raise RedefinedError(name)
+ else:
+ self._con[name] = var
+
+ def get(self, name):
+ try:
+ return self._con[name]
+ except KeyError:
+ raise NotDefinedError(name)
+
+ def __contains__(self, name):
+ return name in self._con
+
+ def __len__(self):
+ return len(self._con)
+
+ def __repr__(self):
+ return pprint.pformat(self._con)
+
+ def __hash__(self):
+ return hash(self.name)
+
+ def __iter__(self):
+ return self._con.iterkeys()
+
+ def __eq__(self, other):
+ if type(self) is type(other):
+ # check keys only, else __eq__ ref cycles, scope -> varmap -> var
+ return self._con.keys() == other._con.keys()
+ return False
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+
+class AbstractRHS(object):
+ """Abstract base class for anything that can be the RHS of an assignment.
+ This class **does not** define any methods.
+ """
+
+
+class Inst(EqualityCheckMixin, AbstractRHS):
+ """
+ Base class for all IR instructions.
+ """
+
+ def list_vars(self):
+ """
+ List the variables used (read or written) by the instruction.
+ """
+ raise NotImplementedError
+
+ def _rec_list_vars(self, val):
+ """
+ A recursive helper used to implement list_vars() in subclasses.
+ """
+ if isinstance(val, Var):
+ return [val]
+ elif isinstance(val, Inst):
+ return val.list_vars()
+ elif isinstance(val, (list, tuple)):
+ lst = []
+ for v in val:
+ lst.extend(self._rec_list_vars(v))
+ return lst
+ elif isinstance(val, dict):
+ lst = []
+ for v in val.values():
+ lst.extend(self._rec_list_vars(v))
+ return lst
+ else:
+ return []
+
+
+class Stmt(Inst):
+ """
+ Base class for IR statements (instructions which can appear on their
+ own in a Block).
+ """
+ # Whether this statement ends its basic block (i.e. it will either jump
+ # to another block or exit the function).
+ is_terminator = False
+ # Whether this statement exits the function.
+ is_exit = False
+
+ def list_vars(self):
+ return self._rec_list_vars(self.__dict__)
+
+
+class Terminator(Stmt):
+ """
+ IR statements that are terminators: the last statement in a block.
+ A terminator must either:
+ - exit the function
+ - jump to a block
+
+ All subclass of Terminator must override `.get_targets()` to return a list
+ of jump targets.
+ """
+ is_terminator = True
+
+ def get_targets(self):
+ raise NotImplementedError(type(self))
+
+
+class Expr(Inst):
+ """
+ An IR expression (an instruction which can only be part of a larger
+ statement).
+ """
+
+ def __init__(self, op, loc, **kws):
+ assert isinstance(op, str)
+ assert isinstance(loc, Loc)
+ self.op = op
+ self.loc = loc
+ self._kws = kws
+
+ def __getattr__(self, name):
+ if name.startswith('_'):
+ return Inst.__getattr__(self, name)
+ return self._kws[name]
+
+ def __setattr__(self, name, value):
+ if name in ('op', 'loc', '_kws'):
+ self.__dict__[name] = value
+ else:
+ self._kws[name] = value
+
+ @classmethod
+ def binop(cls, fn, lhs, rhs, loc):
+ assert isinstance(fn, BuiltinFunctionType)
+ assert isinstance(lhs, Var)
+ assert isinstance(rhs, Var)
+ assert isinstance(loc, Loc)
+ op = 'binop'
+ return cls(op=op, loc=loc, fn=fn, lhs=lhs, rhs=rhs,
+ static_lhs=UNDEFINED, static_rhs=UNDEFINED)
+
+ @classmethod
+ def inplace_binop(cls, fn, immutable_fn, lhs, rhs, loc):
+ assert isinstance(fn, BuiltinFunctionType)
+ assert isinstance(immutable_fn, BuiltinFunctionType)
+ assert isinstance(lhs, Var)
+ assert isinstance(rhs, Var)
+ assert isinstance(loc, Loc)
+ op = 'inplace_binop'
+ return cls(op=op, loc=loc, fn=fn, immutable_fn=immutable_fn,
+ lhs=lhs, rhs=rhs,
+ static_lhs=UNDEFINED, static_rhs=UNDEFINED)
+
+ @classmethod
+ def unary(cls, fn, value, loc):
+ assert isinstance(value, (str, Var, FunctionType))
+ assert isinstance(loc, Loc)
+ op = 'unary'
+ fn = UNARY_BUITINS_TO_OPERATORS.get(fn, fn)
+ return cls(op=op, loc=loc, fn=fn, value=value)
+
+ @classmethod
+ def call(cls, func, args, kws, loc, vararg=None, varkwarg=None, target=None):
+ assert isinstance(func, Var)
+ assert isinstance(loc, Loc)
+ op = 'call'
+ return cls(op=op, loc=loc, func=func, args=args, kws=kws,
+ vararg=vararg, varkwarg=varkwarg, target=target)
+
+ @classmethod
+ def build_tuple(cls, items, loc):
+ assert isinstance(loc, Loc)
+ op = 'build_tuple'
+ return cls(op=op, loc=loc, items=items)
+
+ @classmethod
+ def build_list(cls, items, loc):
+ assert isinstance(loc, Loc)
+ op = 'build_list'
+ return cls(op=op, loc=loc, items=items)
+
+ @classmethod
+ def build_set(cls, items, loc):
+ assert isinstance(loc, Loc)
+ op = 'build_set'
+ return cls(op=op, loc=loc, items=items)
+
+ @classmethod
+ def build_map(cls, items, size, literal_value, value_indexes, loc):
+ assert isinstance(loc, Loc)
+ op = 'build_map'
+ return cls(op=op, loc=loc, items=items, size=size,
+ literal_value=literal_value, value_indexes=value_indexes)
+
+ @classmethod
+ def pair_first(cls, value, loc):
+ assert isinstance(value, Var)
+ op = 'pair_first'
+ return cls(op=op, loc=loc, value=value)
+
+ @classmethod
+ def pair_second(cls, value, loc):
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ op = 'pair_second'
+ return cls(op=op, loc=loc, value=value)
+
+ @classmethod
+ def getiter(cls, value, loc):
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ op = 'getiter'
+ return cls(op=op, loc=loc, value=value)
+
+ @classmethod
+ def iternext(cls, value, loc):
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ op = 'iternext'
+ return cls(op=op, loc=loc, value=value)
+
+ @classmethod
+ def exhaust_iter(cls, value, count, loc):
+ assert isinstance(value, Var)
+ assert isinstance(count, int)
+ assert isinstance(loc, Loc)
+ op = 'exhaust_iter'
+ return cls(op=op, loc=loc, value=value, count=count)
+
+ @classmethod
+ def getattr(cls, value, attr, loc):
+ assert isinstance(value, Var)
+ assert isinstance(attr, str)
+ assert isinstance(loc, Loc)
+ op = 'getattr'
+ return cls(op=op, loc=loc, value=value, attr=attr)
+
+ @classmethod
+ def getitem(cls, value, index, loc):
+ assert isinstance(value, Var)
+ assert isinstance(index, Var)
+ assert isinstance(loc, Loc)
+ op = 'getitem'
+ fn = operator.getitem
+ return cls(op=op, loc=loc, value=value, index=index, fn=fn)
+
+ @classmethod
+ def typed_getitem(cls, value, dtype, index, loc):
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ op = 'typed_getitem'
+ return cls(op=op, loc=loc, value=value, dtype=dtype,
+ index=index)
+
+ @classmethod
+ def static_getitem(cls, value, index, index_var, loc):
+ assert isinstance(value, Var)
+ assert index_var is None or isinstance(index_var, Var)
+ assert isinstance(loc, Loc)
+ op = 'static_getitem'
+ fn = operator.getitem
+ return cls(op=op, loc=loc, value=value, index=index,
+ index_var=index_var, fn=fn)
+
+ @classmethod
+ def cast(cls, value, loc):
+ """
+ A node for implicit casting at the return statement
+ """
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ op = 'cast'
+ return cls(op=op, value=value, loc=loc)
+
+ @classmethod
+ def phi(cls, loc):
+ """Phi node
+ """
+ assert isinstance(loc, Loc)
+ return cls(op='phi', incoming_values=[], incoming_blocks=[], loc=loc)
+
+ @classmethod
+ def make_function(cls, name, code, closure, defaults, loc):
+ """
+ A node for making a function object.
+ """
+ assert isinstance(loc, Loc)
+ op = 'make_function'
+ return cls(op=op, name=name, code=code, closure=closure, defaults=defaults, loc=loc)
+
+ @classmethod
+ def null(cls, loc):
+ """
+ A node for null value.
+
+ This node is not handled by type inference. It is only added by
+ post-typing passes.
+ """
+ assert isinstance(loc, Loc)
+ op = 'null'
+ return cls(op=op, loc=loc)
+
+ @classmethod
+ def undef(cls, loc):
+ """
+ A node for undefined value specifically from LOAD_FAST_AND_CLEAR opcode.
+ """
+ assert isinstance(loc, Loc)
+ op = 'undef'
+ return cls(op=op, loc=loc)
+
+ @classmethod
+ def dummy(cls, op, info, loc):
+ """
+ A node for a dummy value.
+
+ This node is a place holder for carrying information through to a point
+ where it is rewritten into something valid. This node is not handled
+ by type inference or lowering. It's presence outside of the interpreter
+ renders IR as illegal.
+ """
+ assert isinstance(loc, Loc)
+ assert isinstance(op, str)
+ return cls(op=op, info=info, loc=loc)
+
+ def __repr__(self):
+ if self.op == 'call':
+ args = ', '.join(str(a) for a in self.args)
+ pres_order = self._kws.items() if config.DIFF_IR == 0 else sorted(self._kws.items())
+ kws = ', '.join('%s=%s' % (k, v) for k, v in pres_order)
+ vararg = '*%s' % (self.vararg,) if self.vararg is not None else ''
+ arglist = ', '.join(filter(None, [args, vararg, kws]))
+ return 'call %s(%s)' % (self.func, arglist)
+ elif self.op == 'binop':
+ lhs, rhs = self.lhs, self.rhs
+ if self.fn == operator.contains:
+ lhs, rhs = rhs, lhs
+ fn = OPERATORS_TO_BUILTINS.get(self.fn, self.fn)
+ return '%s %s %s' % (lhs, fn, rhs)
+ else:
+ pres_order = self._kws.items() if config.DIFF_IR == 0 else sorted(self._kws.items())
+ args = ('%s=%s' % (k, v) for k, v in pres_order)
+ return '%s(%s)' % (self.op, ', '.join(args))
+
+ def list_vars(self):
+ return self._rec_list_vars(self._kws)
+
+ def infer_constant(self):
+ raise ConstantInferenceError('%s' % self, loc=self.loc)
+
+
+class SetItem(Stmt):
+ """
+ target[index] = value
+ """
+
+ def __init__(self, target, index, value, loc):
+ assert isinstance(target, Var)
+ assert isinstance(index, Var)
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ self.target = target
+ self.index = index
+ self.value = value
+ self.loc = loc
+
+ def __repr__(self):
+ return '%s[%s] = %s' % (self.target, self.index, self.value)
+
+
+class StaticSetItem(Stmt):
+ """
+ target[constant index] = value
+ """
+
+ def __init__(self, target, index, index_var, value, loc):
+ assert isinstance(target, Var)
+ assert not isinstance(index, Var)
+ assert isinstance(index_var, Var)
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ self.target = target
+ self.index = index
+ self.index_var = index_var
+ self.value = value
+ self.loc = loc
+
+ def __repr__(self):
+ return '%s[%r] = %s' % (self.target, self.index, self.value)
+
+
+class DelItem(Stmt):
+ """
+ del target[index]
+ """
+
+ def __init__(self, target, index, loc):
+ assert isinstance(target, Var)
+ assert isinstance(index, Var)
+ assert isinstance(loc, Loc)
+ self.target = target
+ self.index = index
+ self.loc = loc
+
+ def __repr__(self):
+ return 'del %s[%s]' % (self.target, self.index)
+
+
+class SetAttr(Stmt):
+ def __init__(self, target, attr, value, loc):
+ assert isinstance(target, Var)
+ assert isinstance(attr, str)
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ self.target = target
+ self.attr = attr
+ self.value = value
+ self.loc = loc
+
+ def __repr__(self):
+ return '(%s).%s = %s' % (self.target, self.attr, self.value)
+
+
+class DelAttr(Stmt):
+ def __init__(self, target, attr, loc):
+ assert isinstance(target, Var)
+ assert isinstance(attr, str)
+ assert isinstance(loc, Loc)
+ self.target = target
+ self.attr = attr
+ self.loc = loc
+
+ def __repr__(self):
+ return 'del (%s).%s' % (self.target, self.attr)
+
+
+class StoreMap(Stmt):
+ def __init__(self, dct, key, value, loc):
+ assert isinstance(dct, Var)
+ assert isinstance(key, Var)
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ self.dct = dct
+ self.key = key
+ self.value = value
+ self.loc = loc
+
+ def __repr__(self):
+ return '%s[%s] = %s' % (self.dct, self.key, self.value)
+
+
+class Del(Stmt):
+ def __init__(self, value, loc):
+ assert isinstance(value, str)
+ assert isinstance(loc, Loc)
+ self.value = value
+ self.loc = loc
+
+ def __str__(self):
+ return "del %s" % self.value
+
+
+class Raise(Terminator):
+ is_exit = True
+
+ def __init__(self, exception, loc):
+ assert exception is None or isinstance(exception, Var)
+ assert isinstance(loc, Loc)
+ self.exception = exception
+ self.loc = loc
+
+ def __str__(self):
+ return "raise %s" % self.exception
+
+ def get_targets(self):
+ return []
+
+
+class StaticRaise(Terminator):
+ """
+ Raise an exception class and arguments known at compile-time.
+ Note that if *exc_class* is None, a bare "raise" statement is implied
+ (i.e. re-raise the current exception).
+ """
+ is_exit = True
+
+ def __init__(self, exc_class, exc_args, loc):
+ assert exc_class is None or isinstance(exc_class, type)
+ assert isinstance(loc, Loc)
+ assert exc_args is None or isinstance(exc_args, tuple)
+ self.exc_class = exc_class
+ self.exc_args = exc_args
+ self.loc = loc
+
+ def __str__(self):
+ if self.exc_class is None:
+ return " raise"
+ elif self.exc_args is None:
+ return " raise %s" % (self.exc_class,)
+ else:
+ return " raise %s(%s)" % (self.exc_class,
+ ", ".join(map(repr, self.exc_args)))
+
+ def get_targets(self):
+ return []
+
+
+class DynamicRaise(Terminator):
+ """
+ Raise an exception class and some argument *values* unknown at compile-time.
+ Note that if *exc_class* is None, a bare "raise" statement is implied
+ (i.e. re-raise the current exception).
+ """
+ is_exit = True
+
+ def __init__(self, exc_class, exc_args, loc):
+ assert exc_class is None or isinstance(exc_class, type)
+ assert isinstance(loc, Loc)
+ assert exc_args is None or isinstance(exc_args, tuple)
+ self.exc_class = exc_class
+ self.exc_args = exc_args
+ self.loc = loc
+
+ def __str__(self):
+ if self.exc_class is None:
+ return " raise"
+ elif self.exc_args is None:
+ return " raise %s" % (self.exc_class,)
+ else:
+ return " raise %s(%s)" % (self.exc_class,
+ ", ".join(map(repr, self.exc_args)))
+
+ def get_targets(self):
+ return []
+
+
+class TryRaise(Stmt):
+ """A raise statement inside a try-block
+ Similar to ``Raise`` but does not terminate.
+ """
+ def __init__(self, exception, loc):
+ assert exception is None or isinstance(exception, Var)
+ assert isinstance(loc, Loc)
+ self.exception = exception
+ self.loc = loc
+
+ def __str__(self):
+ return "try_raise %s" % self.exception
+
+
+class StaticTryRaise(Stmt):
+ """A raise statement inside a try-block.
+ Similar to ``StaticRaise`` but does not terminate.
+ """
+ def __init__(self, exc_class, exc_args, loc):
+ assert exc_class is None or isinstance(exc_class, type)
+ assert isinstance(loc, Loc)
+ assert exc_args is None or isinstance(exc_args, tuple)
+ self.exc_class = exc_class
+ self.exc_args = exc_args
+ self.loc = loc
+
+ def __str__(self):
+ if self.exc_class is None:
+ return f"static_try_raise"
+ elif self.exc_args is None:
+ return f"static_try_raise {self.exc_class}"
+ else:
+ args = ", ".join(map(repr, self.exc_args))
+ return f"static_try_raise {self.exc_class}({args})"
+
+
+class DynamicTryRaise(Stmt):
+ """A raise statement inside a try-block.
+ Similar to ``DynamicRaise`` but does not terminate.
+ """
+ def __init__(self, exc_class, exc_args, loc):
+ assert exc_class is None or isinstance(exc_class, type)
+ assert isinstance(loc, Loc)
+ assert exc_args is None or isinstance(exc_args, tuple)
+ self.exc_class = exc_class
+ self.exc_args = exc_args
+ self.loc = loc
+
+ def __str__(self):
+ if self.exc_class is None:
+ return f"dynamic_try_raise"
+ elif self.exc_args is None:
+ return f"dynamic_try_raise {self.exc_class}"
+ else:
+ args = ", ".join(map(repr, self.exc_args))
+ return f"dynamic_try_raise {self.exc_class}({args})"
+
+
+class Return(Terminator):
+ """
+ Return to caller.
+ """
+ is_exit = True
+
+ def __init__(self, value, loc):
+ assert isinstance(value, Var), type(value)
+ assert isinstance(loc, Loc)
+ self.value = value
+ self.loc = loc
+
+ def __str__(self):
+ return 'return %s' % self.value
+
+ def get_targets(self):
+ return []
+
+
+class Jump(Terminator):
+ """
+ Unconditional branch.
+ """
+
+ def __init__(self, target, loc):
+ assert isinstance(loc, Loc)
+ self.target = target
+ self.loc = loc
+
+ def __str__(self):
+ return 'jump %s' % self.target
+
+ def get_targets(self):
+ return [self.target]
+
+
+class Branch(Terminator):
+ """
+ Conditional branch.
+ """
+
+ def __init__(self, cond, truebr, falsebr, loc):
+ assert isinstance(cond, Var)
+ assert isinstance(loc, Loc)
+ self.cond = cond
+ self.truebr = truebr
+ self.falsebr = falsebr
+ self.loc = loc
+
+ def __str__(self):
+ return 'branch %s, %s, %s' % (self.cond, self.truebr, self.falsebr)
+
+ def get_targets(self):
+ return [self.truebr, self.falsebr]
+
+
+class Assign(Stmt):
+ """
+ Assign to a variable.
+ """
+ def __init__(self, value, target, loc):
+ assert isinstance(value, AbstractRHS)
+ assert isinstance(target, Var)
+ assert isinstance(loc, Loc)
+ self.value = value
+ self.target = target
+ self.loc = loc
+
+ def __str__(self):
+ return '%s = %s' % (self.target, self.value)
+
+
+class Print(Stmt):
+ """
+ Print some values.
+ """
+ def __init__(self, args, vararg, loc):
+ assert all(isinstance(x, Var) for x in args)
+ assert vararg is None or isinstance(vararg, Var)
+ assert isinstance(loc, Loc)
+ self.args = tuple(args)
+ self.vararg = vararg
+ # Constant-inferred arguments
+ self.consts = {}
+ self.loc = loc
+
+ def __str__(self):
+ return 'print(%s)' % ', '.join(str(v) for v in self.args)
+
+
+class Yield(Inst):
+ def __init__(self, value, loc, index):
+ assert isinstance(value, Var)
+ assert isinstance(loc, Loc)
+ self.value = value
+ self.loc = loc
+ self.index = index
+
+ def __str__(self):
+ return 'yield %s' % (self.value,)
+
+ def list_vars(self):
+ return [self.value]
+
+
+class EnterWith(Stmt):
+ """Enter a "with" context
+ """
+ def __init__(self, contextmanager, begin, end, loc):
+ """
+ Parameters
+ ----------
+ contextmanager : IR value
+ begin, end : int
+ The beginning and the ending offset of the with-body.
+ loc : ir.Loc instance
+ Source location
+ """
+ assert isinstance(contextmanager, Var)
+ assert isinstance(loc, Loc)
+ self.contextmanager = contextmanager
+ self.begin = begin
+ self.end = end
+ self.loc = loc
+
+ def __str__(self):
+ return 'enter_with {}'.format(self.contextmanager)
+
+ def list_vars(self):
+ return [self.contextmanager]
+
+
+class PopBlock(Stmt):
+ """Marker statement for a pop block op code"""
+ def __init__(self, loc):
+ assert isinstance(loc, Loc)
+ self.loc = loc
+
+ def __str__(self):
+ return 'pop_block'
+
+
+class Arg(EqualityCheckMixin, AbstractRHS):
+ def __init__(self, name, index, loc):
+ assert isinstance(name, str)
+ assert isinstance(index, int)
+ assert isinstance(loc, Loc)
+ self.name = name
+ self.index = index
+ self.loc = loc
+
+ def __repr__(self):
+ return 'arg(%d, name=%s)' % (self.index, self.name)
+
+ def infer_constant(self):
+ raise ConstantInferenceError('%s' % self, loc=self.loc)
+
+
+class Const(EqualityCheckMixin, AbstractRHS):
+ def __init__(self, value, loc, use_literal_type=True):
+ assert isinstance(loc, Loc)
+ self.value = value
+ self.loc = loc
+ # Note: need better way to tell if this is a literal or not.
+ self.use_literal_type = use_literal_type
+
+ def __repr__(self):
+ return 'const(%s, %s)' % (type(self.value).__name__, self.value)
+
+ def infer_constant(self):
+ return self.value
+
+ def __deepcopy__(self, memo):
+ # Override to not copy constant values in code
+ return Const(
+ value=self.value, loc=self.loc,
+ use_literal_type=self.use_literal_type,
+ )
+
+
+class Global(EqualityCheckMixin, AbstractRHS):
+ def __init__(self, name, value, loc):
+ assert isinstance(loc, Loc)
+ self.name = name
+ self.value = value
+ self.loc = loc
+
+ def __str__(self):
+ return 'global(%s: %s)' % (self.name, self.value)
+
+ def infer_constant(self):
+ return self.value
+
+ def __deepcopy__(self, memo):
+ # don't copy value since it can fail (e.g. modules)
+ # value is readonly and doesn't need copying
+ return Global(self.name, self.value, copy.deepcopy(self.loc))
+
+
+class FreeVar(EqualityCheckMixin, AbstractRHS):
+ """
+ A freevar, as loaded by LOAD_DECREF.
+ (i.e. a variable defined in an enclosing non-global scope)
+ """
+
+ def __init__(self, index, name, value, loc):
+ assert isinstance(index, int)
+ assert isinstance(name, str)
+ assert isinstance(loc, Loc)
+ # index inside __code__.co_freevars
+ self.index = index
+ # variable name
+ self.name = name
+ # frozen value
+ self.value = value
+ self.loc = loc
+
+ def __str__(self):
+ return 'freevar(%s: %s)' % (self.name, self.value)
+
+ def infer_constant(self):
+ return self.value
+
+ def __deepcopy__(self, memo):
+ # Override to not copy constant values in code
+ return FreeVar(index=self.index, name=self.name, value=self.value,
+ loc=self.loc)
+
+
+
+class Var(EqualityCheckMixin, AbstractRHS):
+ """
+ Attributes
+ -----------
+ - scope: Scope
+
+ - name: str
+
+ - loc: Loc
+ Definition location
+ """
+
+ def __init__(self, scope, name, loc):
+ # NOTE: Use of scope=None should be removed.
+ assert scope is None or isinstance(scope, Scope)
+ assert isinstance(name, str)
+ assert isinstance(loc, Loc)
+ self.scope = scope
+ self.name = name
+ self.loc = loc
+
+ def __repr__(self):
+ return 'Var(%s, %s)' % (self.name, self.loc.short())
+
+ def __str__(self):
+ return self.name
+
+ @property
+ def is_temp(self):
+ return self.name.startswith("$")
+
+ @property
+ def unversioned_name(self):
+ """The unversioned name of this variable, i.e. SSA renaming removed
+ """
+ for k, redef_set in self.scope.var_redefinitions.items():
+ if self.name in redef_set:
+ return k
+ return self.name
+
+ @property
+ def versioned_names(self):
+ """Known versioned names for this variable, i.e. known variable names in
+ the scope that have been formed from applying SSA to this variable
+ """
+ return self.scope.get_versions_of(self.unversioned_name)
+
+ @property
+ def all_names(self):
+ """All known versioned and unversioned names for this variable
+ """
+ return self.versioned_names | {self.unversioned_name,}
+
+ def __deepcopy__(self, memo):
+ out = Var(copy.deepcopy(self.scope, memo), self.name, self.loc)
+ memo[id(self)] = out
+ return out
+
+
+class Scope(EqualityCheckMixin):
+ """
+ Attributes
+ -----------
+ - parent: Scope
+ Parent scope
+
+ - localvars: VarMap
+ Scope-local variable map
+
+ - loc: Loc
+ Start of scope location
+
+ """
+
+ def __init__(self, parent, loc):
+ assert parent is None or isinstance(parent, Scope)
+ assert isinstance(loc, Loc)
+ self.parent = parent
+ self.localvars = VarMap()
+ self.loc = loc
+ self.redefined = defaultdict(int)
+ self.var_redefinitions = defaultdict(set)
+
+ def define(self, name, loc):
+ """
+ Define a variable
+ """
+ v = Var(scope=self, name=name, loc=loc)
+ self.localvars.define(v.name, v)
+ return v
+
+ def get(self, name):
+ """
+ Refer to a variable. Returns the latest version.
+ """
+ if name in self.redefined:
+ name = "%s.%d" % (name, self.redefined[name])
+ return self.get_exact(name)
+
+ def get_exact(self, name):
+ """
+ Refer to a variable. The returned variable has the exact
+ name (exact variable version).
+ """
+ try:
+ return self.localvars.get(name)
+ except NotDefinedError:
+ if self.has_parent:
+ return self.parent.get(name)
+ else:
+ raise
+
+ def get_or_define(self, name, loc):
+ if name in self.redefined:
+ name = "%s.%d" % (name, self.redefined[name])
+
+ if name not in self.localvars:
+ return self.define(name, loc)
+ else:
+ return self.localvars.get(name)
+
+ def redefine(self, name, loc, rename=True):
+ """
+ Redefine if the name is already defined
+ """
+ if name not in self.localvars:
+ return self.define(name, loc)
+ elif not rename:
+ # Must use the same name if the variable is a cellvar, which
+ # means it could be captured in a closure.
+ return self.localvars.get(name)
+ else:
+ while True:
+ ct = self.redefined[name]
+ self.redefined[name] = ct + 1
+ newname = "%s.%d" % (name, ct + 1)
+ try:
+ res = self.define(newname, loc)
+ except RedefinedError:
+ continue
+ else:
+ self.var_redefinitions[name].add(newname)
+ return res
+
+ def get_versions_of(self, name):
+ """
+ Gets all known versions of a given name
+ """
+ vers = set()
+ def walk(thename):
+ redefs = self.var_redefinitions.get(thename, None)
+ if redefs:
+ for v in redefs:
+ vers.add(v)
+ walk(v)
+ walk(name)
+ return vers
+
+ def make_temp(self, loc):
+ n = len(self.localvars)
+ v = Var(scope=self, name='$%d' % n, loc=loc)
+ self.localvars.define(v.name, v)
+ return v
+
+ @property
+ def has_parent(self):
+ return self.parent is not None
+
+ def __repr__(self):
+ return "Scope(has_parent=%r, num_vars=%d, %s)" % (self.has_parent,
+ len(self.localvars),
+ self.loc)
+
+
+class Block(EqualityCheckMixin):
+ """A code block
+
+ """
+
+ def __init__(self, scope, loc):
+ assert isinstance(scope, Scope)
+ assert isinstance(loc, Loc)
+ self.scope = scope
+ self.body = []
+ self.loc = loc
+
+ def copy(self):
+ block = Block(self.scope, self.loc)
+ block.body = self.body[:]
+ return block
+
+ def find_exprs(self, op=None):
+ """
+ Iterate over exprs of the given *op* in this block.
+ """
+ for inst in self.body:
+ if isinstance(inst, Assign):
+ expr = inst.value
+ if isinstance(expr, Expr):
+ if op is None or expr.op == op:
+ yield expr
+
+ def find_insts(self, cls=None):
+ """
+ Iterate over insts of the given class in this block.
+ """
+ for inst in self.body:
+ if isinstance(inst, cls):
+ yield inst
+
+ def find_variable_assignment(self, name):
+ """
+ Returns the assignment inst associated with variable "name", None if
+ it cannot be found.
+ """
+ for x in self.find_insts(cls=Assign):
+ if x.target.name == name:
+ return x
+ return None
+
+ def prepend(self, inst):
+ assert isinstance(inst, Stmt)
+ self.body.insert(0, inst)
+
+ def append(self, inst):
+ assert isinstance(inst, Stmt)
+ self.body.append(inst)
+
+ def remove(self, inst):
+ assert isinstance(inst, Stmt)
+ del self.body[self.body.index(inst)]
+
+ def clear(self):
+ del self.body[:]
+
+ def dump(self, file=None):
+ # Avoid early bind of sys.stdout as default value
+ file = file or sys.stdout
+ for inst in self.body:
+ if hasattr(inst, 'dump'):
+ inst.dump(file)
+ else:
+ inst_vars = sorted(str(v) for v in inst.list_vars())
+ print(' %-40s %s' % (inst, inst_vars), file=file)
+
+ @property
+ def terminator(self):
+ return self.body[-1]
+
+ @property
+ def is_terminated(self):
+ return self.body and self.body[-1].is_terminator
+
+ def verify(self):
+ if not self.is_terminated:
+ raise VerificationError("Missing block terminator")
+ # Only the last instruction can be a terminator
+ for inst in self.body[:-1]:
+ if inst.is_terminator:
+ raise VerificationError("Terminator before the last "
+ "instruction")
+
+ def insert_after(self, stmt, other):
+ """
+ Insert *stmt* after *other*.
+ """
+ index = self.body.index(other)
+ self.body.insert(index + 1, stmt)
+
+ def insert_before_terminator(self, stmt):
+ assert isinstance(stmt, Stmt)
+ assert self.is_terminated
+ self.body.insert(-1, stmt)
+
+ def __repr__(self):
+ return "" % (self.loc,)
+
+
+class Loop(SlotEqualityCheckMixin):
+ """Describes a loop-block
+ """
+ __slots__ = "entry", "exit"
+
+ def __init__(self, entry, exit):
+ self.entry = entry
+ self.exit = exit
+
+ def __repr__(self):
+ args = self.entry, self.exit
+ return "Loop(entry=%s, exit=%s)" % args
+
+
+class With(SlotEqualityCheckMixin):
+ """Describes a with-block
+ """
+ __slots__ = "entry", "exit"
+
+ def __init__(self, entry, exit):
+ self.entry = entry
+ self.exit = exit
+
+ def __repr__(self):
+ args = self.entry, self.exit
+ return "With(entry=%s, exit=%s)" % args
+
+
+class FunctionIR(object):
+
+ def __init__(self, blocks, is_generator, func_id, loc,
+ definitions, arg_count, arg_names):
+ self.blocks = blocks
+ self.is_generator = is_generator
+ self.func_id = func_id
+ self.loc = loc
+ self.arg_count = arg_count
+ self.arg_names = arg_names
+
+ self._definitions = definitions
+
+ self._reset_analysis_variables()
+
+ def equal_ir(self, other):
+ """ Checks that the IR contained within is equal to the IR in other.
+ Equality is defined by being equal in fundamental structure (blocks,
+ labels, IR node type and the order in which they are defined) and the
+ IR nodes being equal. IR node equality essentially comes down to
+ ensuring a node's `.__dict__` or `.__slots__` is equal, with the
+ exception of ignoring 'loc' and 'scope' entries. The upshot is that the
+ comparison is essentially location and scope invariant, but otherwise
+ behaves as unsurprisingly as possible.
+ """
+ if type(self) is type(other):
+ return self.blocks == other.blocks
+ return False
+
+ def diff_str(self, other):
+ """
+ Compute a human readable difference in the IR, returns a formatted
+ string ready for printing.
+ """
+ msg = []
+ for label, block in self.blocks.items():
+ other_blk = other.blocks.get(label, None)
+ if other_blk is not None:
+ if block != other_blk:
+ msg.append(("Block %s differs" % label).center(80, '-'))
+ # see if the instructions are just a permutation
+ block_del = [x for x in block.body if isinstance(x, Del)]
+ oth_del = [x for x in other_blk.body if isinstance(x, Del)]
+ if block_del != oth_del:
+ # this is a common issue, dels are all present, but
+ # order shuffled.
+ if sorted(block_del) == sorted(oth_del):
+ msg.append(("Block %s contains the same dels but "
+ "their order is different") % label)
+ if len(block.body) > len(other_blk.body):
+ msg.append("This block contains more statements")
+ elif len(block.body) < len(other_blk.body):
+ msg.append("Other block contains more statements")
+
+ # find the indexes where they don't match
+ tmp = []
+ for idx, stmts in enumerate(zip(block.body,
+ other_blk.body)):
+ b_s, o_s = stmts
+ if b_s != o_s:
+ tmp.append(idx)
+
+ def get_pad(ablock, l):
+ pointer = '-> '
+ sp = len(pointer) * ' '
+ pad = []
+ nstmt = len(ablock)
+ for i in range(nstmt):
+ if i in tmp:
+ item = pointer
+ elif i >= l:
+ item = pointer
+ else:
+ item = sp
+ pad.append(item)
+ return pad
+
+ min_stmt_len = min(len(block.body), len(other_blk.body))
+
+ with StringIO() as buf:
+ it = [("self", block), ("other", other_blk)]
+ for name, _block in it:
+ buf.truncate(0)
+ _block.dump(file=buf)
+ stmts = buf.getvalue().splitlines()
+ pad = get_pad(_block.body, min_stmt_len)
+ title = ("%s: block %s" % (name, label))
+ msg.append(title.center(80, '-'))
+ msg.extend(["{0}{1}".format(a, b) for a, b in
+ zip(pad, stmts)])
+ if msg == []:
+ msg.append("IR is considered equivalent.")
+ return '\n'.join(msg)
+
+ def _reset_analysis_variables(self):
+
+ self._consts = consts.ConstantInference(self)
+
+ # Will be computed by PostProcessor
+ self.generator_info = None
+ self.variable_lifetime = None
+ # { ir.Block: { variable names (potentially) alive at start of block } }
+ self.block_entry_vars = {}
+
+ def derive(self, blocks, arg_count=None, arg_names=None,
+ force_non_generator=False, loc=None):
+ """
+ Derive a new function IR from this one, using the given blocks,
+ and possibly modifying the argument count and generator flag.
+
+ Post-processing will have to be run again on the new IR.
+ """
+ firstblock = blocks[min(blocks)]
+
+ new_ir = copy.copy(self)
+ new_ir.blocks = blocks
+ new_ir.loc = firstblock.loc if loc is None else loc
+ if force_non_generator:
+ new_ir.is_generator = False
+ if arg_count is not None:
+ new_ir.arg_count = arg_count
+ if arg_names is not None:
+ new_ir.arg_names = arg_names
+ new_ir._reset_analysis_variables()
+ # Make fresh func_id
+ new_ir.func_id = new_ir.func_id.derive()
+ return new_ir
+
+ def copy(self):
+ new_ir = copy.copy(self)
+ blocks = {}
+ block_entry_vars = {}
+ for label, block in self.blocks.items():
+ new_block = block.copy()
+ blocks[label] = new_block
+ if block in self.block_entry_vars:
+ block_entry_vars[new_block] = self.block_entry_vars[block]
+ new_ir.blocks = blocks
+ new_ir.block_entry_vars = block_entry_vars
+ return new_ir
+
+ def get_block_entry_vars(self, block):
+ """
+ Return a set of variable names possibly alive at the beginning of
+ the block.
+ """
+ return self.block_entry_vars[block]
+
+ def infer_constant(self, name):
+ """
+ Try to infer the constant value of a given variable.
+ """
+ if isinstance(name, Var):
+ name = name.name
+ return self._consts.infer_constant(name)
+
+ def get_definition(self, value, lhs_only=False):
+ """
+ Get the definition site for the given variable name or instance.
+ A Expr instance is returned by default, but if lhs_only is set
+ to True, the left-hand-side variable is returned instead.
+ """
+ lhs = value
+ while True:
+ if isinstance(value, Var):
+ lhs = value
+ name = value.name
+ elif isinstance(value, str):
+ lhs = value
+ name = value
+ else:
+ return lhs if lhs_only else value
+ defs = self._definitions[name]
+ if len(defs) == 0:
+ raise KeyError("no definition for %r"
+ % (name,))
+ if len(defs) > 1:
+ raise KeyError("more than one definition for %r"
+ % (name,))
+ value = defs[0]
+
+ def get_assignee(self, rhs_value, in_blocks=None):
+ """
+ Finds the assignee for a given RHS value. If in_blocks is given the
+ search will be limited to the specified blocks.
+ """
+ if in_blocks is None:
+ blocks = self.blocks.values()
+ elif isinstance(in_blocks, int):
+ blocks = [self.blocks[in_blocks]]
+ else:
+ blocks = [self.blocks[blk] for blk in list(in_blocks)]
+
+ assert isinstance(rhs_value, AbstractRHS)
+
+ for blk in blocks:
+ for assign in blk.find_insts(Assign):
+ if assign.value == rhs_value:
+ return assign.target
+
+ raise ValueError("Could not find an assignee for %s" % rhs_value)
+
+
+ def dump(self, file=None):
+ nofile = file is None
+ # Avoid early bind of sys.stdout as default value
+ file = file or StringIO()
+ for offset, block in sorted(self.blocks.items()):
+ print('label %s:' % (offset,), file=file)
+ block.dump(file=file)
+ if nofile:
+ text = file.getvalue()
+ if config.HIGHLIGHT_DUMPS:
+ try:
+ import pygments
+ except ImportError:
+ msg = "Please install pygments to see highlighted dumps"
+ raise ValueError(msg)
+ else:
+ from pygments import highlight
+ from numba.misc.dump_style import NumbaIRLexer as lexer
+ from numba.misc.dump_style import by_colorscheme
+ from pygments.formatters import Terminal256Formatter
+ print(highlight(text, lexer(), Terminal256Formatter(
+ style=by_colorscheme())))
+ else:
+ print(text)
+
+
+ def dump_to_string(self):
+ with StringIO() as sb:
+ self.dump(file=sb)
+ return sb.getvalue()
+
+ def dump_generator_info(self, file=None):
+ file = file or sys.stdout
+ gi = self.generator_info
+ print("generator state variables:", sorted(gi.state_vars), file=file)
+ for index, yp in sorted(gi.yield_points.items()):
+ print("yield point #%d: live variables = %s, weak live variables = %s"
+ % (index, sorted(yp.live_vars), sorted(yp.weak_live_vars)),
+ file=file)
+
+ def render_dot(self, filename_prefix="numba_ir", include_ir=True):
+ """Render the CFG of the IR with GraphViz DOT via the
+ ``graphviz`` python binding.
+
+ Returns
+ -------
+ g : graphviz.Digraph
+ Use `g.view()` to open the graph in the default PDF application.
+ """
+
+ try:
+ import graphviz as gv
+ except ImportError:
+ raise ImportError(
+ "The feature requires `graphviz` but it is not available. "
+ "Please install with `pip install graphviz`"
+ )
+ g = gv.Digraph(
+ filename="{}{}.dot".format(
+ filename_prefix,
+ self.func_id.unique_name,
+ )
+ )
+ # Populate the nodes
+ for k, blk in self.blocks.items():
+ with StringIO() as sb:
+ blk.dump(sb)
+ label = sb.getvalue()
+ if include_ir:
+ label = ''.join(
+ [r' {}\l'.format(x) for x in label.splitlines()],
+ )
+ label = r"block {}\l".format(k) + label
+ g.node(str(k), label=label, shape='rect')
+ else:
+ label = r"{}\l".format(k)
+ g.node(str(k), label=label, shape='circle')
+ # Populate the edges
+ for src, blk in self.blocks.items():
+ for dst in blk.terminator.get_targets():
+ g.edge(str(src), str(dst))
+ return g
+
+
+# A stub for undefined global reference
+class UndefinedType(EqualityCheckMixin):
+
+ _singleton = None
+
+ def __new__(cls):
+ obj = cls._singleton
+ if obj is not None:
+ return obj
+ else:
+ obj = object.__new__(cls)
+ cls._singleton = obj
+ return obj
+
+ def __repr__(self):
+ return "Undefined"
+
+
+UNDEFINED = UndefinedType()
diff --git a/venv/lib/python3.10/site-packages/numba/core/ir_utils.py b/venv/lib/python3.10/site-packages/numba/core/ir_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..063badd3bd575e3757f752a1ee49b10818abefc6
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/ir_utils.py
@@ -0,0 +1,2409 @@
+#
+# Copyright (c) 2017 Intel Corporation
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+import numpy
+import math
+
+import types as pytypes
+import collections
+import warnings
+
+import numba
+from numba.core.extending import _Intrinsic
+from numba.core import types, typing, ir, analysis, postproc, rewrites, config
+from numba.core.typing.templates import signature
+from numba.core.analysis import (compute_live_map, compute_use_defs,
+ compute_cfg_from_blocks)
+from numba.core.errors import (TypingError, UnsupportedError,
+ NumbaPendingDeprecationWarning,
+ CompilerError)
+
+import copy
+
+_unique_var_count = 0
+
+
+def mk_unique_var(prefix):
+ global _unique_var_count
+ var = prefix + "." + str(_unique_var_count)
+ _unique_var_count = _unique_var_count + 1
+ return var
+
+
+class _MaxLabel:
+ def __init__(self, value=0):
+ self._value = value
+
+ def next(self):
+ self._value += 1
+ return self._value
+
+ def update(self, newval):
+ self._value = max(newval, self._value)
+
+
+_the_max_label = _MaxLabel()
+del _MaxLabel
+
+
+def get_unused_var_name(prefix, var_table):
+ """ Get a new var name with a given prefix and
+ make sure it is unused in the given variable table.
+ """
+ cur = 0
+ while True:
+ var = prefix + str(cur)
+ if var not in var_table:
+ return var
+ cur += 1
+
+
+def next_label():
+ return _the_max_label.next()
+
+
+def mk_alloc(typingctx, typemap, calltypes, lhs, size_var, dtype, scope, loc,
+ lhs_typ):
+ """generate an array allocation with np.empty() and return list of nodes.
+ size_var can be an int variable or tuple of int variables.
+ lhs_typ is the type of the array being allocated.
+ """
+ out = []
+ ndims = 1
+ size_typ = types.intp
+ if isinstance(size_var, tuple):
+ if len(size_var) == 1:
+ size_var = size_var[0]
+ size_var = convert_size_to_var(size_var, typemap, scope, loc, out)
+ else:
+ # tuple_var = build_tuple([size_var...])
+ ndims = len(size_var)
+ tuple_var = ir.Var(scope, mk_unique_var("$tuple_var"), loc)
+ if typemap:
+ typemap[tuple_var.name] = types.containers.UniTuple(
+ types.intp, ndims)
+ # constant sizes need to be assigned to vars
+ new_sizes = [convert_size_to_var(s, typemap, scope, loc, out)
+ for s in size_var]
+ tuple_call = ir.Expr.build_tuple(new_sizes, loc)
+ tuple_assign = ir.Assign(tuple_call, tuple_var, loc)
+ out.append(tuple_assign)
+ size_var = tuple_var
+ size_typ = types.containers.UniTuple(types.intp, ndims)
+ if hasattr(lhs_typ, "__allocate__"):
+ return lhs_typ.__allocate__(
+ typingctx,
+ typemap,
+ calltypes,
+ lhs,
+ size_var,
+ dtype,
+ scope,
+ loc,
+ lhs_typ,
+ size_typ,
+ out,
+ )
+ # g_np_var = Global(numpy)
+ g_np_var = ir.Var(scope, mk_unique_var("$np_g_var"), loc)
+ if typemap:
+ typemap[g_np_var.name] = types.misc.Module(numpy)
+ g_np = ir.Global('np', numpy, loc)
+ g_np_assign = ir.Assign(g_np, g_np_var, loc)
+ # attr call: empty_attr = getattr(g_np_var, empty)
+ empty_attr_call = ir.Expr.getattr(g_np_var, "empty", loc)
+ attr_var = ir.Var(scope, mk_unique_var("$empty_attr_attr"), loc)
+ if typemap:
+ typemap[attr_var.name] = get_np_ufunc_typ(numpy.empty)
+ attr_assign = ir.Assign(empty_attr_call, attr_var, loc)
+ # Assume str(dtype) returns a valid type
+ dtype_str = str(dtype)
+ # alloc call: lhs = empty_attr(size_var, typ_var)
+ typ_var = ir.Var(scope, mk_unique_var("$np_typ_var"), loc)
+ if typemap:
+ typemap[typ_var.name] = types.functions.NumberClass(dtype)
+ # If dtype is a datetime/timedelta with a unit,
+ # then it won't return a valid type and instead can be created
+ # with a string. i.e. "datetime64[ns]")
+ if (isinstance(dtype, (types.NPDatetime, types.NPTimedelta)) and
+ dtype.unit != ''):
+ typename_const = ir.Const(dtype_str, loc)
+ typ_var_assign = ir.Assign(typename_const, typ_var, loc)
+ else:
+ if dtype_str=='bool':
+ # empty doesn't like 'bool' sometimes (e.g. kmeans example)
+ dtype_str = 'bool_'
+ np_typ_getattr = ir.Expr.getattr(g_np_var, dtype_str, loc)
+ typ_var_assign = ir.Assign(np_typ_getattr, typ_var, loc)
+ alloc_call = ir.Expr.call(attr_var, [size_var, typ_var], (), loc)
+
+ if calltypes:
+ cac = typemap[attr_var.name].get_call_type(
+ typingctx, [size_typ, types.functions.NumberClass(dtype)], {})
+ # By default, all calls to "empty" are typed as returning a standard
+ # NumPy ndarray. If we are allocating a ndarray subclass here then
+ # just change the return type to be that of the subclass.
+ cac._return_type = (lhs_typ.copy(layout='C')
+ if lhs_typ.layout == 'F'
+ else lhs_typ)
+ calltypes[alloc_call] = cac
+ if lhs_typ.layout == 'F':
+ empty_c_typ = lhs_typ.copy(layout='C')
+ empty_c_var = ir.Var(scope, mk_unique_var("$empty_c_var"), loc)
+ if typemap:
+ typemap[empty_c_var.name] = lhs_typ.copy(layout='C')
+ empty_c_assign = ir.Assign(alloc_call, empty_c_var, loc)
+
+ # attr call: asfortranarray = getattr(g_np_var, asfortranarray)
+ asfortranarray_attr_call = ir.Expr.getattr(g_np_var, "asfortranarray", loc)
+ afa_attr_var = ir.Var(scope, mk_unique_var("$asfortran_array_attr"), loc)
+ if typemap:
+ typemap[afa_attr_var.name] = get_np_ufunc_typ(numpy.asfortranarray)
+ afa_attr_assign = ir.Assign(asfortranarray_attr_call, afa_attr_var, loc)
+ # call asfortranarray
+ asfortranarray_call = ir.Expr.call(afa_attr_var, [empty_c_var], (), loc)
+ if calltypes:
+ calltypes[asfortranarray_call] = typemap[afa_attr_var.name].get_call_type(
+ typingctx, [empty_c_typ], {})
+
+ asfortranarray_assign = ir.Assign(asfortranarray_call, lhs, loc)
+
+ out.extend([g_np_assign, attr_assign, typ_var_assign, empty_c_assign,
+ afa_attr_assign, asfortranarray_assign])
+ else:
+ alloc_assign = ir.Assign(alloc_call, lhs, loc)
+ out.extend([g_np_assign, attr_assign, typ_var_assign, alloc_assign])
+
+ return out
+
+
+def convert_size_to_var(size_var, typemap, scope, loc, nodes):
+ if isinstance(size_var, int):
+ new_size = ir.Var(scope, mk_unique_var("$alloc_size"), loc)
+ if typemap:
+ typemap[new_size.name] = types.intp
+ size_assign = ir.Assign(ir.Const(size_var, loc), new_size, loc)
+ nodes.append(size_assign)
+ return new_size
+ assert isinstance(size_var, ir.Var)
+ return size_var
+
+
+def get_np_ufunc_typ(func):
+ """get type of the incoming function from builtin registry"""
+ for (k, v) in typing.npydecl.registry.globals:
+ if k == func:
+ return v
+ for (k, v) in typing.templates.builtin_registry.globals:
+ if k == func:
+ return v
+ raise RuntimeError("type for func ", func, " not found")
+
+
+def mk_range_block(typemap, start, stop, step, calltypes, scope, loc):
+ """make a block that initializes loop range and iteration variables.
+ target label in jump needs to be set.
+ """
+ # g_range_var = Global(range)
+ g_range_var = ir.Var(scope, mk_unique_var("$range_g_var"), loc)
+ typemap[g_range_var.name] = get_global_func_typ(range)
+ g_range = ir.Global('range', range, loc)
+ g_range_assign = ir.Assign(g_range, g_range_var, loc)
+ arg_nodes, args = _mk_range_args(typemap, start, stop, step, scope, loc)
+ # range_call_var = call g_range_var(start, stop, step)
+ range_call = ir.Expr.call(g_range_var, args, (), loc)
+ calltypes[range_call] = typemap[g_range_var.name].get_call_type(
+ typing.Context(), [types.intp] * len(args), {})
+ #signature(types.range_state64_type, types.intp)
+ range_call_var = ir.Var(scope, mk_unique_var("$range_c_var"), loc)
+ typemap[range_call_var.name] = types.iterators.RangeType(types.intp)
+ range_call_assign = ir.Assign(range_call, range_call_var, loc)
+ # iter_var = getiter(range_call_var)
+ iter_call = ir.Expr.getiter(range_call_var, loc)
+ if config.USE_LEGACY_TYPE_SYSTEM:
+ calltype_sig = signature(types.range_iter64_type, types.range_state64_type)
+ else:
+ calltype_sig = signature(types.range_iter_type, types.range_state_type)
+ calltypes[iter_call] = calltype_sig
+ iter_var = ir.Var(scope, mk_unique_var("$iter_var"), loc)
+ typemap[iter_var.name] = types.iterators.RangeIteratorType(types.intp)
+ iter_call_assign = ir.Assign(iter_call, iter_var, loc)
+ # $phi = iter_var
+ phi_var = ir.Var(scope, mk_unique_var("$phi"), loc)
+ typemap[phi_var.name] = types.iterators.RangeIteratorType(types.intp)
+ phi_assign = ir.Assign(iter_var, phi_var, loc)
+ # jump to header
+ jump_header = ir.Jump(-1, loc)
+ range_block = ir.Block(scope, loc)
+ range_block.body = arg_nodes + [g_range_assign, range_call_assign,
+ iter_call_assign, phi_assign, jump_header]
+ return range_block
+
+
+def _mk_range_args(typemap, start, stop, step, scope, loc):
+ nodes = []
+ if isinstance(stop, ir.Var):
+ g_stop_var = stop
+ else:
+ assert isinstance(stop, int)
+ g_stop_var = ir.Var(scope, mk_unique_var("$range_stop"), loc)
+ if typemap:
+ typemap[g_stop_var.name] = types.intp
+ stop_assign = ir.Assign(ir.Const(stop, loc), g_stop_var, loc)
+ nodes.append(stop_assign)
+ if start == 0 and step == 1:
+ return nodes, [g_stop_var]
+
+ if isinstance(start, ir.Var):
+ g_start_var = start
+ else:
+ assert isinstance(start, int)
+ g_start_var = ir.Var(scope, mk_unique_var("$range_start"), loc)
+ if typemap:
+ typemap[g_start_var.name] = types.intp
+ start_assign = ir.Assign(ir.Const(start, loc), g_start_var, loc)
+ nodes.append(start_assign)
+ if step == 1:
+ return nodes, [g_start_var, g_stop_var]
+
+ if isinstance(step, ir.Var):
+ g_step_var = step
+ else:
+ assert isinstance(step, int)
+ g_step_var = ir.Var(scope, mk_unique_var("$range_step"), loc)
+ if typemap:
+ typemap[g_step_var.name] = types.intp
+ step_assign = ir.Assign(ir.Const(step, loc), g_step_var, loc)
+ nodes.append(step_assign)
+
+ return nodes, [g_start_var, g_stop_var, g_step_var]
+
+
+def get_global_func_typ(func):
+ """get type variable for func() from builtin registry"""
+ for (k, v) in typing.templates.builtin_registry.globals:
+ if k == func:
+ return v
+ raise RuntimeError("func type not found {}".format(func))
+
+
+def mk_loop_header(typemap, phi_var, calltypes, scope, loc):
+ """make a block that is a loop header updating iteration variables.
+ target labels in branch need to be set.
+ """
+ # iternext_var = iternext(phi_var)
+ iternext_var = ir.Var(scope, mk_unique_var("$iternext_var"), loc)
+ typemap[iternext_var.name] = types.containers.Pair(
+ types.intp, types.boolean)
+ iternext_call = ir.Expr.iternext(phi_var, loc)
+ if config.USE_LEGACY_TYPE_SYSTEM:
+ range_iter_type = types.range_iter64_type
+ else:
+ range_iter_type = types.range_iter_type
+ calltypes[iternext_call] = signature(
+ types.containers.Pair(
+ types.intp,
+ types.boolean),
+ range_iter_type)
+ iternext_assign = ir.Assign(iternext_call, iternext_var, loc)
+ # pair_first_var = pair_first(iternext_var)
+ pair_first_var = ir.Var(scope, mk_unique_var("$pair_first_var"), loc)
+ typemap[pair_first_var.name] = types.intp
+ pair_first_call = ir.Expr.pair_first(iternext_var, loc)
+ pair_first_assign = ir.Assign(pair_first_call, pair_first_var, loc)
+ # pair_second_var = pair_second(iternext_var)
+ pair_second_var = ir.Var(scope, mk_unique_var("$pair_second_var"), loc)
+ typemap[pair_second_var.name] = types.boolean
+ pair_second_call = ir.Expr.pair_second(iternext_var, loc)
+ pair_second_assign = ir.Assign(pair_second_call, pair_second_var, loc)
+ # phi_b_var = pair_first_var
+ phi_b_var = ir.Var(scope, mk_unique_var("$phi"), loc)
+ typemap[phi_b_var.name] = types.intp
+ phi_b_assign = ir.Assign(pair_first_var, phi_b_var, loc)
+ # branch pair_second_var body_block out_block
+ branch = ir.Branch(pair_second_var, -1, -1, loc)
+ header_block = ir.Block(scope, loc)
+ header_block.body = [iternext_assign, pair_first_assign,
+ pair_second_assign, phi_b_assign, branch]
+ return header_block
+
+
+def legalize_names(varnames):
+ """returns a dictionary for conversion of variable names to legal
+ parameter names.
+ """
+ var_map = {}
+ for var in varnames:
+ new_name = var.replace("_", "__").replace("$", "_").replace(".", "_")
+ assert new_name not in var_map
+ var_map[var] = new_name
+ return var_map
+
+
+def get_name_var_table(blocks):
+ """create a mapping from variable names to their ir.Var objects"""
+ def get_name_var_visit(var, namevar):
+ namevar[var.name] = var
+ return var
+ namevar = {}
+ visit_vars(blocks, get_name_var_visit, namevar)
+ return namevar
+
+
+def replace_var_names(blocks, namedict):
+ """replace variables (ir.Var to ir.Var) from dictionary (name -> name)"""
+ # remove identity values to avoid infinite loop
+ new_namedict = {}
+ for l, r in namedict.items():
+ if l != r:
+ new_namedict[l] = r
+
+ def replace_name(var, namedict):
+ assert isinstance(var, ir.Var)
+ while var.name in namedict:
+ var = ir.Var(var.scope, namedict[var.name], var.loc)
+ return var
+ visit_vars(blocks, replace_name, new_namedict)
+
+
+def replace_var_callback(var, vardict):
+ assert isinstance(var, ir.Var)
+ while var.name in vardict.keys():
+ assert(vardict[var.name].name != var.name)
+ new_var = vardict[var.name]
+ var = ir.Var(new_var.scope, new_var.name, new_var.loc)
+ return var
+
+
+def replace_vars(blocks, vardict):
+ """replace variables (ir.Var to ir.Var) from dictionary (name -> ir.Var)"""
+ # remove identity values to avoid infinite loop
+ new_vardict = {}
+ for l, r in vardict.items():
+ if l != r.name:
+ new_vardict[l] = r
+ visit_vars(blocks, replace_var_callback, new_vardict)
+
+
+def replace_vars_stmt(stmt, vardict):
+ visit_vars_stmt(stmt, replace_var_callback, vardict)
+
+
+def replace_vars_inner(node, vardict):
+ return visit_vars_inner(node, replace_var_callback, vardict)
+
+
+# other packages that define new nodes add calls to visit variables in them
+# format: {type:function}
+visit_vars_extensions = {}
+
+
+def visit_vars(blocks, callback, cbdata):
+ """go over statements of block bodies and replace variable names with
+ dictionary.
+ """
+ for block in blocks.values():
+ for stmt in block.body:
+ visit_vars_stmt(stmt, callback, cbdata)
+ return
+
+
+def visit_vars_stmt(stmt, callback, cbdata):
+ # let external calls handle stmt if type matches
+ for t, f in visit_vars_extensions.items():
+ if isinstance(stmt, t):
+ f(stmt, callback, cbdata)
+ return
+ if isinstance(stmt, ir.Assign):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
+ elif isinstance(stmt, ir.Arg):
+ stmt.name = visit_vars_inner(stmt.name, callback, cbdata)
+ elif isinstance(stmt, ir.Return):
+ stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
+ elif isinstance(stmt, ir.Raise):
+ stmt.exception = visit_vars_inner(stmt.exception, callback, cbdata)
+ elif isinstance(stmt, ir.Branch):
+ stmt.cond = visit_vars_inner(stmt.cond, callback, cbdata)
+ elif isinstance(stmt, ir.Jump):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ elif isinstance(stmt, ir.Del):
+ # Because Del takes only a var name, we make up by
+ # constructing a temporary variable.
+ var = ir.Var(None, stmt.value, stmt.loc)
+ var = visit_vars_inner(var, callback, cbdata)
+ stmt.value = var.name
+ elif isinstance(stmt, ir.DelAttr):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ stmt.attr = visit_vars_inner(stmt.attr, callback, cbdata)
+ elif isinstance(stmt, ir.SetAttr):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ stmt.attr = visit_vars_inner(stmt.attr, callback, cbdata)
+ stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
+ elif isinstance(stmt, ir.DelItem):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ stmt.index = visit_vars_inner(stmt.index, callback, cbdata)
+ elif isinstance(stmt, ir.StaticSetItem):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ stmt.index_var = visit_vars_inner(stmt.index_var, callback, cbdata)
+ stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
+ elif isinstance(stmt, ir.SetItem):
+ stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
+ stmt.index = visit_vars_inner(stmt.index, callback, cbdata)
+ stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
+ elif isinstance(stmt, ir.Print):
+ stmt.args = [visit_vars_inner(x, callback, cbdata) for x in stmt.args]
+ else:
+ # TODO: raise NotImplementedError("no replacement for IR node: ", stmt)
+ pass
+ return
+
+
+def visit_vars_inner(node, callback, cbdata):
+ if isinstance(node, ir.Var):
+ return callback(node, cbdata)
+ elif isinstance(node, list):
+ return [visit_vars_inner(n, callback, cbdata) for n in node]
+ elif isinstance(node, tuple):
+ return tuple([visit_vars_inner(n, callback, cbdata) for n in node])
+ elif isinstance(node, ir.Expr):
+ # if node.op in ['binop', 'inplace_binop']:
+ # lhs = node.lhs.name
+ # rhs = node.rhs.name
+ # node.lhs.name = callback, cbdata.get(lhs, lhs)
+ # node.rhs.name = callback, cbdata.get(rhs, rhs)
+ for arg in node._kws.keys():
+ node._kws[arg] = visit_vars_inner(node._kws[arg], callback, cbdata)
+ elif isinstance(node, ir.Yield):
+ node.value = visit_vars_inner(node.value, callback, cbdata)
+ return node
+
+
+add_offset_to_labels_extensions = {}
+
+
+def add_offset_to_labels(blocks, offset):
+ """add an offset to all block labels and jump/branch targets
+ """
+ new_blocks = {}
+ for l, b in blocks.items():
+ # some parfor last blocks might be empty
+ term = None
+ if b.body:
+ term = b.body[-1]
+ for inst in b.body:
+ for T, f in add_offset_to_labels_extensions.items():
+ if isinstance(inst, T):
+ f_max = f(inst, offset)
+ if isinstance(term, ir.Jump):
+ b.body[-1] = ir.Jump(term.target + offset, term.loc)
+ if isinstance(term, ir.Branch):
+ b.body[-1] = ir.Branch(term.cond, term.truebr + offset,
+ term.falsebr + offset, term.loc)
+ new_blocks[l + offset] = b
+ return new_blocks
+
+
+find_max_label_extensions = {}
+
+
+def find_max_label(blocks):
+ max_label = 0
+ for l, b in blocks.items():
+ term = None
+ if b.body:
+ term = b.body[-1]
+ for inst in b.body:
+ for T, f in find_max_label_extensions.items():
+ if isinstance(inst, T):
+ f_max = f(inst)
+ if f_max > max_label:
+ max_label = f_max
+ if l > max_label:
+ max_label = l
+ return max_label
+
+
+def flatten_labels(blocks):
+ """makes the labels in range(0, len(blocks)), useful to compare CFGs
+ """
+ # first bulk move the labels out of the rewrite range
+ blocks = add_offset_to_labels(blocks, find_max_label(blocks) + 1)
+ # order them in topo order because it's easier to read
+ new_blocks = {}
+ topo_order = find_topo_order(blocks)
+ l_map = dict()
+ idx = 0
+ for x in topo_order:
+ l_map[x] = idx
+ idx += 1
+
+ for t_node in topo_order:
+ b = blocks[t_node]
+ # some parfor last blocks might be empty
+ term = None
+ if b.body:
+ term = b.body[-1]
+ if isinstance(term, ir.Jump):
+ b.body[-1] = ir.Jump(l_map[term.target], term.loc)
+ if isinstance(term, ir.Branch):
+ b.body[-1] = ir.Branch(term.cond, l_map[term.truebr],
+ l_map[term.falsebr], term.loc)
+ new_blocks[l_map[t_node]] = b
+ return new_blocks
+
+
+def remove_dels(blocks):
+ """remove ir.Del nodes"""
+ for block in blocks.values():
+ new_body = []
+ for stmt in block.body:
+ if not isinstance(stmt, ir.Del):
+ new_body.append(stmt)
+ block.body = new_body
+ return
+
+
+def remove_args(blocks):
+ """remove ir.Arg nodes"""
+ for block in blocks.values():
+ new_body = []
+ for stmt in block.body:
+ if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Arg):
+ continue
+ new_body.append(stmt)
+ block.body = new_body
+ return
+
+
+def dead_code_elimination(func_ir, typemap=None, alias_map=None,
+ arg_aliases=None):
+ """ Performs dead code elimination and leaves the IR in a valid state on
+ exit
+ """
+ do_post_proc = False
+ while (remove_dead(func_ir.blocks, func_ir.arg_names, func_ir, typemap,
+ alias_map, arg_aliases)):
+ do_post_proc = True
+
+ if do_post_proc:
+ post_proc = postproc.PostProcessor(func_ir)
+ post_proc.run()
+
+
+def remove_dead(blocks, args, func_ir, typemap=None, alias_map=None, arg_aliases=None):
+ """dead code elimination using liveness and CFG info.
+ Returns True if something has been removed, or False if nothing is removed.
+ """
+ cfg = compute_cfg_from_blocks(blocks)
+ usedefs = compute_use_defs(blocks)
+ live_map = compute_live_map(cfg, blocks, usedefs.usemap, usedefs.defmap)
+ call_table, _ = get_call_table(blocks)
+ if alias_map is None or arg_aliases is None:
+ alias_map, arg_aliases = find_potential_aliases(blocks, args, typemap,
+ func_ir)
+ if config.DEBUG_ARRAY_OPT >= 1:
+ print("args:", args)
+ print("alias map:", alias_map)
+ print("arg_aliases:", arg_aliases)
+ print("live_map:", live_map)
+ print("usemap:", usedefs.usemap)
+ print("defmap:", usedefs.defmap)
+ # keep set for easier search
+ alias_set = set(alias_map.keys())
+
+ removed = False
+ for label, block in blocks.items():
+ # find live variables at each statement to delete dead assignment
+ lives = {v.name for v in block.terminator.list_vars()}
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("remove_dead processing block", label, lives)
+ # find live variables at the end of block
+ for out_blk, _data in cfg.successors(label):
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("succ live_map", out_blk, live_map[out_blk])
+ lives |= live_map[out_blk]
+ removed |= remove_dead_block(block, lives, call_table, arg_aliases,
+ alias_map, alias_set, func_ir, typemap)
+
+ return removed
+
+
+# other packages that define new nodes add calls to remove dead code in them
+# format: {type:function}
+remove_dead_extensions = {}
+
+
+def remove_dead_block(block, lives, call_table, arg_aliases, alias_map,
+ alias_set, func_ir, typemap):
+ """remove dead code using liveness info.
+ Mutable arguments (e.g. arrays) that are not definitely assigned are live
+ after return of function.
+ """
+ # TODO: find mutable args that are not definitely assigned instead of
+ # assuming all args are live after return
+ removed = False
+
+ # add statements in reverse order
+ new_body = [block.terminator]
+ # for each statement in reverse order, excluding terminator
+ for stmt in reversed(block.body[:-1]):
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("remove_dead_block", stmt)
+ # aliases of lives are also live
+ alias_lives = set()
+ init_alias_lives = lives & alias_set
+ for v in init_alias_lives:
+ alias_lives |= alias_map[v]
+ lives_n_aliases = lives | alias_lives | arg_aliases
+
+ # let external calls handle stmt if type matches
+ if type(stmt) in remove_dead_extensions:
+ f = remove_dead_extensions[type(stmt)]
+ stmt = f(stmt, lives, lives_n_aliases, arg_aliases, alias_map, func_ir,
+ typemap)
+ if stmt is None:
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("Statement was removed.")
+ removed = True
+ continue
+
+ # ignore assignments that their lhs is not live or lhs==rhs
+ if isinstance(stmt, ir.Assign):
+ lhs = stmt.target
+ rhs = stmt.value
+ if lhs.name not in lives and has_no_side_effect(
+ rhs, lives_n_aliases, call_table):
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("Statement was removed.")
+ removed = True
+ continue
+ if isinstance(rhs, ir.Var) and lhs.name == rhs.name:
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("Statement was removed.")
+ removed = True
+ continue
+ # TODO: remove other nodes like SetItem etc.
+
+ if isinstance(stmt, ir.Del):
+ if stmt.value not in lives:
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("Statement was removed.")
+ removed = True
+ continue
+
+ if isinstance(stmt, ir.SetItem):
+ name = stmt.target.name
+ if name not in lives_n_aliases:
+ if config.DEBUG_ARRAY_OPT >= 2:
+ print("Statement was removed.")
+ continue
+
+ if type(stmt) in analysis.ir_extension_usedefs:
+ def_func = analysis.ir_extension_usedefs[type(stmt)]
+ uses, defs = def_func(stmt)
+ lives -= defs
+ lives |= uses
+ else:
+ lives |= {v.name for v in stmt.list_vars()}
+ if isinstance(stmt, ir.Assign):
+ # make sure lhs is not used in rhs, e.g. a = g(a)
+ if isinstance(stmt.value, ir.Expr):
+ rhs_vars = {v.name for v in stmt.value.list_vars()}
+ if lhs.name not in rhs_vars:
+ lives.remove(lhs.name)
+ else:
+ lives.remove(lhs.name)
+
+ new_body.append(stmt)
+ new_body.reverse()
+ block.body = new_body
+ return removed
+
+# list of functions
+remove_call_handlers = []
+
+def remove_dead_random_call(rhs, lives, call_list):
+ if len(call_list) == 3 and call_list[1:] == ['random', numpy]:
+ return call_list[0] not in {'seed', 'shuffle'}
+ return False
+
+remove_call_handlers.append(remove_dead_random_call)
+
+def has_no_side_effect(rhs, lives, call_table):
+ """ Returns True if this expression has no side effects that
+ would prevent re-ordering.
+ """
+ from numba.parfors import array_analysis, parfor
+ from numba.misc.special import prange
+ if isinstance(rhs, ir.Expr) and rhs.op == 'call':
+ func_name = rhs.func.name
+ if func_name not in call_table or call_table[func_name] == []:
+ return False
+ call_list = call_table[func_name]
+ if (call_list == ['empty', numpy] or
+ call_list == [slice] or
+ call_list == ['stencil', numba] or
+ call_list == ['log', numpy] or
+ call_list == ['dtype', numpy] or
+ call_list == [array_analysis.wrap_index] or
+ call_list == [prange] or
+ call_list == ['prange', numba] or
+ call_list == ['pndindex', numba] or
+ call_list == [parfor.internal_prange] or
+ call_list == ['ceil', math] or
+ call_list == [max] or
+ call_list == [int]):
+ return True
+ elif (isinstance(call_list[0], _Intrinsic) and
+ (call_list[0]._name == 'empty_inferred' or
+ call_list[0]._name == 'unsafe_empty_inferred')):
+ return True
+ from numba.core.registry import CPUDispatcher
+ from numba.np.linalg import dot_3_mv_check_args
+ if isinstance(call_list[0], CPUDispatcher):
+ py_func = call_list[0].py_func
+ if py_func == dot_3_mv_check_args:
+ return True
+ for f in remove_call_handlers:
+ if f(rhs, lives, call_list):
+ return True
+ return False
+ if isinstance(rhs, ir.Expr) and rhs.op == 'inplace_binop':
+ return rhs.lhs.name not in lives
+ if isinstance(rhs, ir.Yield):
+ return False
+ if isinstance(rhs, ir.Expr) and rhs.op == 'pair_first':
+ # don't remove pair_first since prange looks for it
+ return False
+ return True
+
+is_pure_extensions = []
+
+def is_pure(rhs, lives, call_table):
+ """ Returns True if every time this expression is evaluated it
+ returns the same result. This is not the case for things
+ like calls to numpy.random.
+ """
+ if isinstance(rhs, ir.Expr):
+ if rhs.op == 'call':
+ func_name = rhs.func.name
+ if func_name not in call_table or call_table[func_name] == []:
+ return False
+ call_list = call_table[func_name]
+ if (call_list == [slice] or
+ call_list == ['log', numpy] or
+ call_list == ['empty', numpy] or
+ call_list == ['ceil', math] or
+ call_list == [max] or
+ call_list == [int]):
+ return True
+ for f in is_pure_extensions:
+ if f(rhs, lives, call_list):
+ return True
+ return False
+ elif rhs.op == 'getiter' or rhs.op == 'iternext':
+ return False
+ if isinstance(rhs, ir.Yield):
+ return False
+ return True
+
+def is_const_call(module_name, func_name):
+ # Returns True if there is no state in the given module changed by the given function.
+ if module_name == 'numpy':
+ if func_name in ['empty']:
+ return True
+ return False
+
+alias_analysis_extensions = {}
+alias_func_extensions = {}
+
+def get_canonical_alias(v, alias_map):
+ if v not in alias_map:
+ return v
+
+ v_aliases = sorted(list(alias_map[v]))
+ return v_aliases[0]
+
+def find_potential_aliases(blocks, args, typemap, func_ir, alias_map=None,
+ arg_aliases=None):
+ "find all array aliases and argument aliases to avoid remove as dead"
+ if alias_map is None:
+ alias_map = {}
+ if arg_aliases is None:
+ arg_aliases = set(a for a in args if not is_immutable_type(a, typemap))
+
+ # update definitions since they are not guaranteed to be up-to-date
+ # FIXME keep definitions up-to-date to avoid the need for rebuilding
+ func_ir._definitions = build_definitions(func_ir.blocks)
+ np_alias_funcs = ['ravel', 'transpose', 'reshape']
+
+ for bl in blocks.values():
+ for instr in bl.body:
+ if type(instr) in alias_analysis_extensions:
+ f = alias_analysis_extensions[type(instr)]
+ f(instr, args, typemap, func_ir, alias_map, arg_aliases)
+ if isinstance(instr, ir.Assign):
+ expr = instr.value
+ lhs = instr.target.name
+ # only mutable types can alias
+ if is_immutable_type(lhs, typemap):
+ continue
+ if isinstance(expr, ir.Var) and lhs!=expr.name:
+ _add_alias(lhs, expr.name, alias_map, arg_aliases)
+ # subarrays like A = B[0] for 2D B
+ if (isinstance(expr, ir.Expr) and (expr.op == 'cast' or
+ expr.op in ['getitem', 'static_getitem'])):
+ _add_alias(lhs, expr.value.name, alias_map, arg_aliases)
+ if isinstance(expr, ir.Expr) and expr.op == 'inplace_binop':
+ _add_alias(lhs, expr.lhs.name, alias_map, arg_aliases)
+ # array attributes like A.T
+ if (isinstance(expr, ir.Expr) and expr.op == 'getattr'
+ and expr.attr in ['T', 'ctypes', 'flat']):
+ _add_alias(lhs, expr.value.name, alias_map, arg_aliases)
+ # a = b.c. a should alias b
+ if (isinstance(expr, ir.Expr) and expr.op == 'getattr'
+ and expr.attr not in ['shape']
+ and expr.value.name in arg_aliases):
+ _add_alias(lhs, expr.value.name, alias_map, arg_aliases)
+ # calls that can create aliases such as B = A.ravel()
+ if isinstance(expr, ir.Expr) and expr.op == 'call':
+ fdef = guard(find_callname, func_ir, expr, typemap)
+ # TODO: sometimes gufunc backend creates duplicate code
+ # causing find_callname to fail. Example: test_argmax
+ # ignored here since those cases don't create aliases
+ # but should be fixed in general
+ if fdef is None:
+ continue
+ fname, fmod = fdef
+ if fdef in alias_func_extensions:
+ alias_func = alias_func_extensions[fdef]
+ alias_func(lhs, expr.args, alias_map, arg_aliases)
+ if fmod == 'numpy' and fname in np_alias_funcs:
+ _add_alias(lhs, expr.args[0].name, alias_map, arg_aliases)
+ if isinstance(fmod, ir.Var) and fname in np_alias_funcs:
+ _add_alias(lhs, fmod.name, alias_map, arg_aliases)
+
+ # copy to avoid changing size during iteration
+ old_alias_map = copy.deepcopy(alias_map)
+ # combine all aliases transitively
+ for v in old_alias_map:
+ for w in old_alias_map[v]:
+ alias_map[v] |= alias_map[w]
+ for w in old_alias_map[v]:
+ alias_map[w] = alias_map[v]
+
+ return alias_map, arg_aliases
+
+def _add_alias(lhs, rhs, alias_map, arg_aliases):
+ if rhs in arg_aliases:
+ arg_aliases.add(lhs)
+ else:
+ if rhs not in alias_map:
+ alias_map[rhs] = set()
+ if lhs not in alias_map:
+ alias_map[lhs] = set()
+ alias_map[rhs].add(lhs)
+ alias_map[lhs].add(rhs)
+ return
+
+def is_immutable_type(var, typemap):
+ # Conservatively, assume mutable if type not available
+ if typemap is None or var not in typemap:
+ return False
+ typ = typemap[var]
+ # TODO: add more immutable types
+ if isinstance(typ, (types.Number, types.scalars._NPDatetimeBase,
+ types.iterators.RangeType)):
+ return True
+ if typ==types.string:
+ return True
+ # conservatively, assume mutable
+ return False
+
+def copy_propagate(blocks, typemap):
+ """compute copy propagation information for each block using fixed-point
+ iteration on data flow equations:
+ in_b = intersect(predec(B))
+ out_b = gen_b | (in_b - kill_b)
+ """
+ cfg = compute_cfg_from_blocks(blocks)
+ entry = cfg.entry_point()
+
+ # format: dict of block labels to copies as tuples
+ # label -> (l,r)
+ c_data = init_copy_propagate_data(blocks, entry, typemap)
+ (gen_copies, all_copies, kill_copies, in_copies, out_copies) = c_data
+
+ old_point = None
+ new_point = copy.deepcopy(out_copies)
+ # comparison works since dictionary of built-in types
+ while old_point != new_point:
+ for label in blocks.keys():
+ if label == entry:
+ continue
+ predecs = [i for i, _d in cfg.predecessors(label)]
+ # in_b = intersect(predec(B))
+ in_copies[label] = out_copies[predecs[0]].copy()
+ for p in predecs:
+ in_copies[label] &= out_copies[p]
+
+ # out_b = gen_b | (in_b - kill_b)
+ out_copies[label] = (gen_copies[label]
+ | (in_copies[label] - kill_copies[label]))
+ old_point = new_point
+ new_point = copy.deepcopy(out_copies)
+ if config.DEBUG_ARRAY_OPT >= 1:
+ print("copy propagate out_copies:", out_copies)
+ return in_copies, out_copies
+
+
+def init_copy_propagate_data(blocks, entry, typemap):
+ """get initial condition of copy propagation data flow for each block.
+ """
+ # gen is all definite copies, extra_kill is additional ones that may hit
+ # for example, parfors can have control flow so they may hit extra copies
+ gen_copies, extra_kill = get_block_copies(blocks, typemap)
+ # set of all program copies
+ all_copies = set()
+ for l, s in gen_copies.items():
+ all_copies |= gen_copies[l]
+ kill_copies = {}
+ for label, gen_set in gen_copies.items():
+ kill_copies[label] = set()
+ for lhs, rhs in all_copies:
+ if lhs in extra_kill[label] or rhs in extra_kill[label]:
+ kill_copies[label].add((lhs, rhs))
+ # a copy is killed if it is not in this block and lhs or rhs are
+ # assigned in this block
+ assigned = {lhs for lhs, rhs in gen_set}
+ if ((lhs, rhs) not in gen_set
+ and (lhs in assigned or rhs in assigned)):
+ kill_copies[label].add((lhs, rhs))
+ # set initial values
+ # all copies are in for all blocks except entry
+ in_copies = {l: all_copies.copy() for l in blocks.keys()}
+ in_copies[entry] = set()
+ out_copies = {}
+ for label in blocks.keys():
+ # out_b = gen_b | (in_b - kill_b)
+ out_copies[label] = (gen_copies[label]
+ | (in_copies[label] - kill_copies[label]))
+ out_copies[entry] = gen_copies[entry]
+ return (gen_copies, all_copies, kill_copies, in_copies, out_copies)
+
+
+# other packages that define new nodes add calls to get copies in them
+# format: {type:function}
+copy_propagate_extensions = {}
+
+
+def get_block_copies(blocks, typemap):
+ """get copies generated and killed by each block
+ """
+ block_copies = {}
+ extra_kill = {}
+ for label, block in blocks.items():
+ assign_dict = {}
+ extra_kill[label] = set()
+ # assignments as dict to replace with latest value
+ for stmt in block.body:
+ for T, f in copy_propagate_extensions.items():
+ if isinstance(stmt, T):
+ gen_set, kill_set = f(stmt, typemap)
+ for lhs, rhs in gen_set:
+ assign_dict[lhs] = rhs
+ # if a=b is in dict and b is killed, a is also killed
+ new_assign_dict = {}
+ for l, r in assign_dict.items():
+ if l not in kill_set and r not in kill_set:
+ new_assign_dict[l] = r
+ if r in kill_set:
+ extra_kill[label].add(l)
+ assign_dict = new_assign_dict
+ extra_kill[label] |= kill_set
+ if isinstance(stmt, ir.Assign):
+ lhs = stmt.target.name
+ if isinstance(stmt.value, ir.Var):
+ rhs = stmt.value.name
+ # copy is valid only if same type (see
+ # TestCFunc.test_locals)
+ # Some transformations can produce assignments of the
+ # form A = A. We don't put these mapping in the
+ # copy propagation set because then you get cycles and
+ # infinite loops in the replacement phase.
+ if typemap[lhs] == typemap[rhs] and lhs != rhs:
+ assign_dict[lhs] = rhs
+ continue
+ if isinstance(stmt.value,
+ ir.Expr) and stmt.value.op == 'inplace_binop':
+ in1_var = stmt.value.lhs.name
+ in1_typ = typemap[in1_var]
+ # inplace_binop assigns first operand if mutable
+ if not (isinstance(in1_typ, types.Number)
+ or in1_typ == types.string):
+ extra_kill[label].add(in1_var)
+ # if a=b is in dict and b is killed, a is also killed
+ new_assign_dict = {}
+ for l, r in assign_dict.items():
+ if l != in1_var and r != in1_var:
+ new_assign_dict[l] = r
+ if r == in1_var:
+ extra_kill[label].add(l)
+ assign_dict = new_assign_dict
+ extra_kill[label].add(lhs)
+ block_cps = set(assign_dict.items())
+ block_copies[label] = block_cps
+ return block_copies, extra_kill
+
+
+# other packages that define new nodes add calls to apply copy propagate in them
+# format: {type:function}
+apply_copy_propagate_extensions = {}
+
+
+def apply_copy_propagate(blocks, in_copies, name_var_table, typemap, calltypes,
+ save_copies=None):
+ """apply copy propagation to IR: replace variables when copies available"""
+ # save_copies keeps an approximation of the copies that were applied, so
+ # that the variable names of removed user variables can be recovered to some
+ # extent.
+ if save_copies is None:
+ save_copies = []
+
+ for label, block in blocks.items():
+ var_dict = {l: name_var_table[r] for l, r in in_copies[label]}
+ # assignments as dict to replace with latest value
+ for stmt in block.body:
+ if type(stmt) in apply_copy_propagate_extensions:
+ f = apply_copy_propagate_extensions[type(stmt)]
+ f(stmt, var_dict, name_var_table,
+ typemap, calltypes, save_copies)
+ # only rhs of assignments should be replaced
+ # e.g. if x=y is available, x in x=z shouldn't be replaced
+ elif isinstance(stmt, ir.Assign):
+ stmt.value = replace_vars_inner(stmt.value, var_dict)
+ else:
+ replace_vars_stmt(stmt, var_dict)
+ fix_setitem_type(stmt, typemap, calltypes)
+ for T, f in copy_propagate_extensions.items():
+ if isinstance(stmt, T):
+ gen_set, kill_set = f(stmt, typemap)
+ for lhs, rhs in gen_set:
+ if rhs in name_var_table:
+ var_dict[lhs] = name_var_table[rhs]
+ for l, r in var_dict.copy().items():
+ if l in kill_set or r.name in kill_set:
+ var_dict.pop(l)
+ if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Var):
+ lhs = stmt.target.name
+ rhs = stmt.value.name
+ # rhs could be replaced with lhs from previous copies
+ if lhs != rhs:
+ # copy is valid only if same type (see
+ # TestCFunc.test_locals)
+ if typemap[lhs] == typemap[rhs] and rhs in name_var_table:
+ var_dict[lhs] = name_var_table[rhs]
+ else:
+ var_dict.pop(lhs, None)
+ # a=b kills previous t=a
+ lhs_kill = []
+ for k, v in var_dict.items():
+ if v.name == lhs:
+ lhs_kill.append(k)
+ for k in lhs_kill:
+ var_dict.pop(k, None)
+ if (isinstance(stmt, ir.Assign)
+ and not isinstance(stmt.value, ir.Var)):
+ lhs = stmt.target.name
+ var_dict.pop(lhs, None)
+ # previous t=a is killed if a is killed
+ lhs_kill = []
+ for k, v in var_dict.items():
+ if v.name == lhs:
+ lhs_kill.append(k)
+ for k in lhs_kill:
+ var_dict.pop(k, None)
+ save_copies.extend(var_dict.items())
+
+ return save_copies
+
+def fix_setitem_type(stmt, typemap, calltypes):
+ """Copy propagation can replace setitem target variable, which can be array
+ with 'A' layout. The replaced variable can be 'C' or 'F', so we update
+ setitem call type reflect this (from matrix power test)
+ """
+ if not isinstance(stmt, (ir.SetItem, ir.StaticSetItem)):
+ return
+ t_typ = typemap[stmt.target.name]
+ s_typ = calltypes[stmt].args[0]
+ # test_optional t_typ can be Optional with array
+ if not isinstance(
+ s_typ,
+ types.npytypes.Array) or not isinstance(
+ t_typ,
+ types.npytypes.Array):
+ return
+ if s_typ.layout == 'A' and t_typ.layout != 'A':
+ new_s_typ = s_typ.copy(layout=t_typ.layout)
+ calltypes[stmt].args = (
+ new_s_typ,
+ calltypes[stmt].args[1],
+ calltypes[stmt].args[2])
+ return
+
+
+def dprint_func_ir(func_ir, title, blocks=None):
+ """Debug print function IR, with an optional blocks argument
+ that may differ from the IR's original blocks.
+ """
+ if config.DEBUG_ARRAY_OPT >= 1:
+ ir_blocks = func_ir.blocks
+ func_ir.blocks = ir_blocks if blocks == None else blocks
+ name = func_ir.func_id.func_qualname
+ print(("IR %s: %s" % (title, name)).center(80, "-"))
+ func_ir.dump()
+ print("-" * 40)
+ func_ir.blocks = ir_blocks
+
+
+def find_topo_order(blocks, cfg = None):
+ """find topological order of blocks such that true branches are visited
+ first (e.g. for_break test in test_dataflow). This is written as an iterative
+ implementation of post order traversal to avoid recursion limit issues.
+ """
+ if cfg is None:
+ cfg = compute_cfg_from_blocks(blocks)
+
+ post_order = []
+ # Has the node already added its children?
+ seen = set()
+ # Has the node already been pushed to post order?
+ visited = set()
+ stack = [cfg.entry_point()]
+
+ while len(stack) > 0:
+ node = stack[-1]
+ if node not in visited and node not in seen:
+ # We haven't added a node or its children.
+ seen.add(node)
+ succs = cfg._succs[node]
+ last_inst = blocks[node].body[-1]
+ if isinstance(last_inst, ir.Branch):
+ succs = [last_inst.truebr, last_inst.falsebr]
+ for dest in succs:
+ if (node, dest) not in cfg._back_edges:
+ if dest not in seen:
+ stack.append(dest)
+ else:
+ # This node has already added its children. We either need
+ # to visit the node or it has been added multiple times in
+ # which case we should just skip the node.
+ node = stack.pop()
+ if node not in visited:
+ post_order.append(node)
+ visited.add(node)
+ if node in seen:
+ # Remove the node from seen if it exists to limit the memory
+ # usage to 1 entry per node. Otherwise the memory requirement
+ # can double the recursive version.
+ seen.remove(node)
+
+ post_order.reverse()
+ return post_order
+
+
+# other packages that define new nodes add calls to get call table
+# format: {type:function}
+call_table_extensions = {}
+
+
+def get_call_table(blocks, call_table=None, reverse_call_table=None, topological_ordering=True):
+ """returns a dictionary of call variables and their references.
+ """
+ # call_table example: c = np.zeros becomes c:["zeroes", np]
+ # reverse_call_table example: c = np.zeros becomes np_var:c
+ if call_table is None:
+ call_table = {}
+ if reverse_call_table is None:
+ reverse_call_table = {}
+
+ if topological_ordering:
+ order = find_topo_order(blocks)
+ else:
+ order = list(blocks.keys())
+
+ for label in reversed(order):
+ for inst in reversed(blocks[label].body):
+ if isinstance(inst, ir.Assign):
+ lhs = inst.target.name
+ rhs = inst.value
+ if isinstance(rhs, ir.Expr) and rhs.op == 'call':
+ call_table[rhs.func.name] = []
+ if isinstance(rhs, ir.Expr) and rhs.op == 'getattr':
+ if lhs in call_table:
+ call_table[lhs].append(rhs.attr)
+ reverse_call_table[rhs.value.name] = lhs
+ if lhs in reverse_call_table:
+ call_var = reverse_call_table[lhs]
+ call_table[call_var].append(rhs.attr)
+ reverse_call_table[rhs.value.name] = call_var
+ if isinstance(rhs, ir.Global):
+ if lhs in call_table:
+ call_table[lhs].append(rhs.value)
+ if lhs in reverse_call_table:
+ call_var = reverse_call_table[lhs]
+ call_table[call_var].append(rhs.value)
+ if isinstance(rhs, ir.FreeVar):
+ if lhs in call_table:
+ call_table[lhs].append(rhs.value)
+ if lhs in reverse_call_table:
+ call_var = reverse_call_table[lhs]
+ call_table[call_var].append(rhs.value)
+ if isinstance(rhs, ir.Var):
+ if lhs in call_table:
+ call_table[lhs].append(rhs.name)
+ reverse_call_table[rhs.name] = lhs
+ if lhs in reverse_call_table:
+ call_var = reverse_call_table[lhs]
+ call_table[call_var].append(rhs.name)
+ for T, f in call_table_extensions.items():
+ if isinstance(inst, T):
+ f(inst, call_table, reverse_call_table)
+ return call_table, reverse_call_table
+
+
+# other packages that define new nodes add calls to get tuple table
+# format: {type:function}
+tuple_table_extensions = {}
+
+
+def get_tuple_table(blocks, tuple_table=None):
+ """returns a dictionary of tuple variables and their values.
+ """
+ if tuple_table is None:
+ tuple_table = {}
+
+ for block in blocks.values():
+ for inst in block.body:
+ if isinstance(inst, ir.Assign):
+ lhs = inst.target.name
+ rhs = inst.value
+ if isinstance(rhs, ir.Expr) and rhs.op == 'build_tuple':
+ tuple_table[lhs] = rhs.items
+ if isinstance(rhs, ir.Const) and isinstance(rhs.value, tuple):
+ tuple_table[lhs] = rhs.value
+ for T, f in tuple_table_extensions.items():
+ if isinstance(inst, T):
+ f(inst, tuple_table)
+ return tuple_table
+
+
+def get_stmt_writes(stmt):
+ writes = set()
+ if isinstance(stmt, (ir.Assign, ir.SetItem, ir.StaticSetItem)):
+ writes.add(stmt.target.name)
+ return writes
+
+
+def rename_labels(blocks):
+ """rename labels of function body blocks according to topological sort.
+ The set of labels of these blocks will remain unchanged.
+ """
+ topo_order = find_topo_order(blocks)
+
+ # make a block with return last if available (just for readability)
+ return_label = -1
+ for l, b in blocks.items():
+ if isinstance(b.body[-1], ir.Return):
+ return_label = l
+ # some cases like generators can have no return blocks
+ if return_label != -1:
+ topo_order.remove(return_label)
+ topo_order.append(return_label)
+
+ label_map = {}
+ all_labels = sorted(topo_order, reverse=True)
+ for label in topo_order:
+ label_map[label] = all_labels.pop()
+ # update target labels in jumps/branches
+ for b in blocks.values():
+ term = b.terminator
+ # create new IR nodes instead of mutating the existing one as copies of
+ # the IR may also refer to the same nodes!
+ if isinstance(term, ir.Jump):
+ b.body[-1] = ir.Jump(label_map[term.target], term.loc)
+ if isinstance(term, ir.Branch):
+ b.body[-1] = ir.Branch(term.cond,
+ label_map[term.truebr],
+ label_map[term.falsebr],
+ term.loc)
+
+
+
+ # update blocks dictionary keys
+ new_blocks = {}
+ for k, b in blocks.items():
+ new_label = label_map[k]
+ new_blocks[new_label] = b
+
+ return new_blocks
+
+
+def simplify_CFG(blocks):
+ """transform chains of blocks that have no loop into a single block"""
+ # first, inline single-branch-block to its predecessors
+ cfg = compute_cfg_from_blocks(blocks)
+ def find_single_branch(label):
+ block = blocks[label]
+ return len(block.body) == 1 and isinstance(block.body[0], ir.Branch)
+ single_branch_blocks = list(filter(find_single_branch, blocks.keys()))
+ marked_for_del = set()
+ for label in single_branch_blocks:
+ inst = blocks[label].body[0]
+ predecessors = cfg.predecessors(label)
+ delete_block = True
+ for (p, q) in predecessors:
+ block = blocks[p]
+ if isinstance(block.body[-1], ir.Jump):
+ block.body[-1] = copy.copy(inst)
+ else:
+ delete_block = False
+ if delete_block:
+ marked_for_del.add(label)
+ # Delete marked labels
+ for label in marked_for_del:
+ del blocks[label]
+ merge_adjacent_blocks(blocks)
+ return rename_labels(blocks)
+
+
+arr_math = ['min', 'max', 'sum', 'prod', 'mean', 'var', 'std',
+ 'cumsum', 'cumprod', 'argmax', 'argmin', 'argsort',
+ 'nonzero', 'ravel']
+
+
+def canonicalize_array_math(func_ir, typemap, calltypes, typingctx):
+ # save array arg to call
+ # call_varname -> array
+ blocks = func_ir.blocks
+ saved_arr_arg = {}
+ topo_order = find_topo_order(blocks)
+ for label in topo_order:
+ block = blocks[label]
+ new_body = []
+ for stmt in block.body:
+ if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Expr):
+ lhs = stmt.target.name
+ rhs = stmt.value
+ # replace A.func with np.func, and save A in saved_arr_arg
+ if (rhs.op == 'getattr' and rhs.attr in arr_math
+ and isinstance(
+ typemap[rhs.value.name], types.npytypes.Array)):
+ rhs = stmt.value
+ arr = rhs.value
+ saved_arr_arg[lhs] = arr
+ scope = arr.scope
+ loc = arr.loc
+ # g_np_var = Global(numpy)
+ g_np_var = ir.Var(scope, mk_unique_var("$np_g_var"), loc)
+ typemap[g_np_var.name] = types.misc.Module(numpy)
+ g_np = ir.Global('np', numpy, loc)
+ g_np_assign = ir.Assign(g_np, g_np_var, loc)
+ rhs.value = g_np_var
+ new_body.append(g_np_assign)
+ func_ir._definitions[g_np_var.name] = [g_np]
+ # update func var type
+ func = getattr(numpy, rhs.attr)
+ func_typ = get_np_ufunc_typ(func)
+ typemap.pop(lhs)
+ typemap[lhs] = func_typ
+ if rhs.op == 'call' and rhs.func.name in saved_arr_arg:
+ # add array as first arg
+ arr = saved_arr_arg[rhs.func.name]
+ # update call type signature to include array arg
+ old_sig = calltypes.pop(rhs)
+ # argsort requires kws for typing so sig.args can't be used
+ # reusing sig.args since some types become Const in sig
+ argtyps = old_sig.args[:len(rhs.args)]
+ kwtyps = {name: typemap[v.name] for name, v in rhs.kws}
+ calltypes[rhs] = typemap[rhs.func.name].get_call_type(
+ typingctx, [typemap[arr.name]] + list(argtyps), kwtyps)
+ rhs.args = [arr] + rhs.args
+
+ new_body.append(stmt)
+ block.body = new_body
+ return
+
+
+# format: {type:function}
+array_accesses_extensions = {}
+
+
+def get_array_accesses(blocks, accesses=None):
+ """returns a set of arrays accessed and their indices.
+ """
+ if accesses is None:
+ accesses = set()
+
+ for block in blocks.values():
+ for inst in block.body:
+ if isinstance(inst, ir.SetItem):
+ accesses.add((inst.target.name, inst.index.name))
+ if isinstance(inst, ir.StaticSetItem):
+ accesses.add((inst.target.name, inst.index_var.name))
+ if isinstance(inst, ir.Assign):
+ lhs = inst.target.name
+ rhs = inst.value
+ if isinstance(rhs, ir.Expr) and rhs.op == 'getitem':
+ accesses.add((rhs.value.name, rhs.index.name))
+ if isinstance(rhs, ir.Expr) and rhs.op == 'static_getitem':
+ index = rhs.index
+ # slice is unhashable, so just keep the variable
+ if index is None or is_slice_index(index):
+ index = rhs.index_var.name
+ accesses.add((rhs.value.name, index))
+ for T, f in array_accesses_extensions.items():
+ if isinstance(inst, T):
+ f(inst, accesses)
+ return accesses
+
+def is_slice_index(index):
+ """see if index is a slice index or has slice in it"""
+ if isinstance(index, slice):
+ return True
+ if isinstance(index, tuple):
+ for i in index:
+ if isinstance(i, slice):
+ return True
+ return False
+
+def merge_adjacent_blocks(blocks):
+ cfg = compute_cfg_from_blocks(blocks)
+ # merge adjacent blocks
+ removed = set()
+ for label in list(blocks.keys()):
+ if label in removed:
+ continue
+ block = blocks[label]
+ succs = list(cfg.successors(label))
+ while True:
+ if len(succs) != 1:
+ break
+ next_label = succs[0][0]
+ if next_label in removed:
+ break
+ preds = list(cfg.predecessors(next_label))
+ succs = list(cfg.successors(next_label))
+ if len(preds) != 1 or preds[0][0] != label:
+ break
+ next_block = blocks[next_label]
+ # XXX: commented out since scope objects are not consistent
+ # throughout the compiler. for example, pieces of code are compiled
+ # and inlined on the fly without proper scope merge.
+ # if block.scope != next_block.scope:
+ # break
+ # merge
+ block.body.pop() # remove Jump
+ block.body += next_block.body
+ del blocks[next_label]
+ removed.add(next_label)
+ label = next_label
+
+
+def restore_copy_var_names(blocks, save_copies, typemap):
+ """
+ restores variable names of user variables after applying copy propagation
+ """
+ if not save_copies:
+ return {}
+
+ rename_dict = {}
+ var_rename_map = {}
+ for (a, b) in save_copies:
+ # a is string name, b is variable
+ # if a is user variable and b is generated temporary and b is not
+ # already renamed
+ if (not a.startswith('$') and b.name.startswith('$')
+ and b.name not in rename_dict):
+ new_name = mk_unique_var('${}'.format(a));
+ rename_dict[b.name] = new_name
+ var_rename_map[new_name] = a
+ typ = typemap.pop(b.name)
+ typemap[new_name] = typ
+
+ replace_var_names(blocks, rename_dict)
+ return var_rename_map
+
+
+def simplify(func_ir, typemap, calltypes, metadata):
+ # get copies in to blocks and out from blocks
+ in_cps, _ = copy_propagate(func_ir.blocks, typemap)
+ # table mapping variable names to ir.Var objects to help replacement
+ name_var_table = get_name_var_table(func_ir.blocks)
+ save_copies = apply_copy_propagate(
+ func_ir.blocks,
+ in_cps,
+ name_var_table,
+ typemap,
+ calltypes)
+ var_rename_map = restore_copy_var_names(func_ir.blocks, save_copies, typemap)
+ if "var_rename_map" not in metadata:
+ metadata["var_rename_map"] = {}
+ metadata["var_rename_map"].update(var_rename_map)
+ # remove dead code to enable fusion
+ if config.DEBUG_ARRAY_OPT >= 1:
+ dprint_func_ir(func_ir, "after copy prop")
+ remove_dead(func_ir.blocks, func_ir.arg_names, func_ir, typemap)
+ func_ir.blocks = simplify_CFG(func_ir.blocks)
+ if config.DEBUG_ARRAY_OPT >= 1:
+ dprint_func_ir(func_ir, "after simplify")
+
+
+class GuardException(Exception):
+ pass
+
+
+def require(cond):
+ """
+ Raise GuardException if the given condition is False.
+ """
+ if not cond:
+ raise GuardException
+
+def guard(func, *args, **kwargs):
+ """
+ Run a function with given set of arguments, and guard against
+ any GuardException raised by the function by returning None,
+ or the expected return results if no such exception was raised.
+ """
+ try:
+ return func(*args, **kwargs)
+ except GuardException:
+ return None
+
+def get_definition(func_ir, name, **kwargs):
+ """
+ Same as func_ir.get_definition(name), but raise GuardException if
+ exception KeyError is caught.
+ """
+ try:
+ return func_ir.get_definition(name, **kwargs)
+ except KeyError:
+ raise GuardException
+
+def build_definitions(blocks, definitions=None):
+ """Build the definitions table of the given blocks by scanning
+ through all blocks and instructions, useful when the definitions
+ table is out-of-sync.
+ Will return a new definition table if one is not passed.
+ """
+ if definitions is None:
+ definitions = collections.defaultdict(list)
+
+ for block in blocks.values():
+ for inst in block.body:
+ if isinstance(inst, ir.Assign):
+ name = inst.target.name
+ definition = definitions.get(name, [])
+ if definition == []:
+ definitions[name] = definition
+ definition.append(inst.value)
+ if type(inst) in build_defs_extensions:
+ f = build_defs_extensions[type(inst)]
+ f(inst, definitions)
+
+ return definitions
+
+build_defs_extensions = {}
+
+def find_callname(func_ir, expr, typemap=None, definition_finder=get_definition):
+ """Try to find a call expression's function and module names and return
+ them as strings for unbounded calls. If the call is a bounded call, return
+ the self object instead of module name. Raise GuardException if failed.
+
+ Providing typemap can make the call matching more accurate in corner cases
+ such as bounded call on an object which is inside another object.
+ """
+ require(isinstance(expr, ir.Expr) and expr.op == 'call')
+ callee = expr.func
+ callee_def = definition_finder(func_ir, callee)
+ attrs = []
+ obj = None
+ while True:
+ if isinstance(callee_def, (ir.Global, ir.FreeVar)):
+ # require(callee_def.value == numpy)
+ # these checks support modules like numpy, numpy.random as well as
+ # calls like len() and intrinsics like assertEquiv
+ keys = ['name', '_name', '__name__']
+ value = None
+ for key in keys:
+ if hasattr(callee_def.value, key):
+ value = getattr(callee_def.value, key)
+ break
+ if not value or not isinstance(value, str):
+ raise GuardException
+ attrs.append(value)
+ def_val = callee_def.value
+ # get the underlying definition of Intrinsic object to be able to
+ # find the module effectively.
+ # Otherwise, it will return numba.extending
+ if isinstance(def_val, _Intrinsic):
+ def_val = def_val._defn
+ if hasattr(def_val, '__module__'):
+ mod_name = def_val.__module__
+ # The reason for first checking if the function is in NumPy's
+ # top level name space by module is that some functions are
+ # deprecated in NumPy but the functions' names are aliased with
+ # other common names. This prevents deprecation warnings on
+ # e.g. getattr(numpy, 'bool') were a bool the target.
+ # For context see #6175, impacts NumPy>=1.20.
+ mod_not_none = mod_name is not None
+ numpy_toplevel = (mod_not_none and
+ (mod_name == 'numpy'
+ or mod_name.startswith('numpy.')))
+ # it might be a numpy function imported directly
+ if (numpy_toplevel and hasattr(numpy, value)
+ and def_val == getattr(numpy, value)):
+ attrs += ['numpy']
+ # it might be a np.random function imported directly
+ elif (hasattr(numpy.random, value)
+ and def_val == getattr(numpy.random, value)):
+ attrs += ['random', 'numpy']
+ elif mod_not_none:
+ attrs.append(mod_name)
+ else:
+ class_name = def_val.__class__.__name__
+ if class_name == 'builtin_function_or_method':
+ class_name = 'builtin'
+ if class_name != 'module':
+ attrs.append(class_name)
+ break
+ elif isinstance(callee_def, ir.Expr) and callee_def.op == 'getattr':
+ obj = callee_def.value
+ attrs.append(callee_def.attr)
+ if typemap and obj.name in typemap:
+ typ = typemap[obj.name]
+ if not isinstance(typ, types.Module):
+ return attrs[0], obj
+ callee_def = definition_finder(func_ir, obj)
+ else:
+ # obj.func calls where obj is not np array
+ if obj is not None:
+ return '.'.join(reversed(attrs)), obj
+ raise GuardException
+ return attrs[0], '.'.join(reversed(attrs[1:]))
+
+def find_build_sequence(func_ir, var):
+ """Check if a variable is constructed via build_tuple or
+ build_list or build_set, and return the sequence and the
+ operator, or raise GuardException otherwise.
+ Note: only build_tuple is immutable, so use with care.
+ """
+ require(isinstance(var, ir.Var))
+ var_def = get_definition(func_ir, var)
+ require(isinstance(var_def, ir.Expr))
+ build_ops = ['build_tuple', 'build_list', 'build_set']
+ require(var_def.op in build_ops)
+ return var_def.items, var_def.op
+
+def find_const(func_ir, var):
+ """Check if a variable is defined as constant, and return
+ the constant value, or raise GuardException otherwise.
+ """
+ require(isinstance(var, ir.Var))
+ var_def = get_definition(func_ir, var)
+ require(isinstance(var_def, (ir.Const, ir.Global, ir.FreeVar)))
+ return var_def.value
+
+def compile_to_numba_ir(mk_func, glbls, typingctx=None, targetctx=None,
+ arg_typs=None, typemap=None, calltypes=None):
+ """
+ Compile a function or a make_function node to Numba IR.
+
+ Rename variables and
+ labels to avoid conflict if inlined somewhere else. Perform type inference
+ if typingctx and other typing inputs are available and update typemap and
+ calltypes.
+ """
+ from numba.core import typed_passes
+ # mk_func can be actual function or make_function node, or a njit function
+ if hasattr(mk_func, 'code'):
+ code = mk_func.code
+ elif hasattr(mk_func, '__code__'):
+ code = mk_func.__code__
+ else:
+ raise NotImplementedError("function type not recognized {}".format(mk_func))
+ f_ir = get_ir_of_code(glbls, code)
+ remove_dels(f_ir.blocks)
+
+ # relabel by adding an offset
+ f_ir.blocks = add_offset_to_labels(f_ir.blocks, _the_max_label.next())
+ max_label = max(f_ir.blocks.keys())
+ _the_max_label.update(max_label)
+
+ # rename all variables to avoid conflict
+ var_table = get_name_var_table(f_ir.blocks)
+ new_var_dict = {}
+ for name, var in var_table.items():
+ new_var_dict[name] = mk_unique_var(name)
+ replace_var_names(f_ir.blocks, new_var_dict)
+
+ # perform type inference if typingctx is available and update type
+ # data structures typemap and calltypes
+ if typingctx:
+ f_typemap, f_return_type, f_calltypes, _ = typed_passes.type_inference_stage(
+ typingctx, targetctx, f_ir, arg_typs, None)
+ # remove argument entries like arg.a from typemap
+ arg_names = [vname for vname in f_typemap if vname.startswith("arg.")]
+ for a in arg_names:
+ f_typemap.pop(a)
+ typemap.update(f_typemap)
+ calltypes.update(f_calltypes)
+ return f_ir
+
+def _create_function_from_code_obj(fcode, func_env, func_arg, func_clo, glbls):
+ """
+ Creates a function from a code object. Args:
+ * fcode - the code object
+ * func_env - string for the freevar placeholders
+ * func_arg - string for the function args (e.g. "a, b, c, d=None")
+ * func_clo - string for the closure args
+ * glbls - the function globals
+ """
+ sanitized_co_name = fcode.co_name.replace('<', '_').replace('>', '_')
+ func_text = (f"def closure():\n{func_env}\n"
+ f"\tdef {sanitized_co_name}({func_arg}):\n"
+ f"\t\treturn ({func_clo})\n"
+ f"\treturn {sanitized_co_name}")
+ loc = {}
+ exec(func_text, glbls, loc)
+
+ f = loc['closure']()
+ # replace the code body
+ f.__code__ = fcode
+ f.__name__ = fcode.co_name
+ return f
+
+def get_ir_of_code(glbls, fcode):
+ """
+ Compile a code object to get its IR, ir.Del nodes are emitted
+ """
+ nfree = len(fcode.co_freevars)
+ func_env = "\n".join(["\tc_%d = None" % i for i in range(nfree)])
+ func_clo = ",".join(["c_%d" % i for i in range(nfree)])
+ func_arg = ",".join(["x_%d" % i for i in range(fcode.co_argcount)])
+
+ f = _create_function_from_code_obj(fcode, func_env, func_arg, func_clo,
+ glbls)
+
+ from numba.core import compiler
+ ir = compiler.run_frontend(f)
+ # we need to run the before inference rewrite pass to normalize the IR
+ # XXX: check rewrite pass flag?
+ # for example, Raise nodes need to become StaticRaise before type inference
+ class DummyPipeline(object):
+ def __init__(self, f_ir):
+ self.state = compiler.StateDict()
+ self.state.typingctx = None
+ self.state.targetctx = None
+ self.state.args = None
+ self.state.func_ir = f_ir
+ self.state.typemap = None
+ self.state.return_type = None
+ self.state.calltypes = None
+ state = DummyPipeline(ir).state
+ rewrites.rewrite_registry.apply('before-inference', state)
+ # call inline pass to handle cases like stencils and comprehensions
+ swapped = {} # TODO: get this from diagnostics store
+ import numba.core.inline_closurecall
+ inline_pass = numba.core.inline_closurecall.InlineClosureCallPass(
+ ir, numba.core.cpu.ParallelOptions(False), swapped)
+ inline_pass.run()
+
+ # TODO: DO NOT ADD MORE THINGS HERE!
+ # If adding more things here is being contemplated, it really is time to
+ # retire this function and work on getting the InlineWorker class from
+ # numba.core.inline_closurecall into sufficient shape as a replacement.
+ # The issue with `get_ir_of_code` is that it doesn't run a full compilation
+ # pipeline and as a result various additional things keep needing to be
+ # added to create valid IR.
+
+ # rebuild IR in SSA form
+ from numba.core.untyped_passes import ReconstructSSA
+ from numba.core.typed_passes import PreLowerStripPhis
+ reconstruct_ssa = ReconstructSSA()
+ phistrip = PreLowerStripPhis()
+ reconstruct_ssa.run_pass(state)
+ phistrip.run_pass(state)
+
+ post_proc = postproc.PostProcessor(ir)
+ post_proc.run(True)
+ return ir
+
+def replace_arg_nodes(block, args):
+ """
+ Replace ir.Arg(...) with variables
+ """
+ for stmt in block.body:
+ if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Arg):
+ idx = stmt.value.index
+ assert(idx < len(args))
+ stmt.value = args[idx]
+ return
+
+
+def replace_returns(blocks, target, return_label):
+ """
+ Return return statement by assigning directly to target, and a jump.
+ """
+ for block in blocks.values():
+ # some blocks may be empty during transformations
+ if not block.body:
+ continue
+ stmt = block.terminator
+ if isinstance(stmt, ir.Return):
+ block.body.pop() # remove return
+ cast_stmt = block.body.pop()
+ assert (isinstance(cast_stmt, ir.Assign)
+ and isinstance(cast_stmt.value, ir.Expr)
+ and cast_stmt.value.op == 'cast'), "invalid return cast"
+ block.body.append(ir.Assign(cast_stmt.value.value, target, stmt.loc))
+ block.body.append(ir.Jump(return_label, stmt.loc))
+
+
+def gen_np_call(func_as_str, func, lhs, args, typingctx, typemap, calltypes):
+ scope = args[0].scope
+ loc = args[0].loc
+
+ # g_np_var = Global(numpy)
+ g_np_var = ir.Var(scope, mk_unique_var("$np_g_var"), loc)
+ typemap[g_np_var.name] = types.misc.Module(numpy)
+ g_np = ir.Global('np', numpy, loc)
+ g_np_assign = ir.Assign(g_np, g_np_var, loc)
+ # attr call: _attr = getattr(g_np_var, func_as_str)
+ np_attr_call = ir.Expr.getattr(g_np_var, func_as_str, loc)
+ attr_var = ir.Var(scope, mk_unique_var("$np_attr_attr"), loc)
+ func_var_typ = get_np_ufunc_typ(func)
+ typemap[attr_var.name] = func_var_typ
+ attr_assign = ir.Assign(np_attr_call, attr_var, loc)
+ # np call: lhs = np_attr(*args)
+ np_call = ir.Expr.call(attr_var, args, (), loc)
+ arg_types = [typemap[x.name] for x in args]
+ func_typ = func_var_typ.get_call_type(typingctx, arg_types, {})
+ calltypes[np_call] = func_typ
+ np_assign = ir.Assign(np_call, lhs, loc)
+ return [g_np_assign, attr_assign, np_assign]
+
+def dump_block(label, block):
+ print(label, ":")
+ for stmt in block.body:
+ print(" ", stmt)
+
+def dump_blocks(blocks):
+ for label, block in blocks.items():
+ dump_block(label, block)
+
+def is_operator_or_getitem(expr):
+ """true if expr is unary or binary operator or getitem"""
+ return (isinstance(expr, ir.Expr)
+ and getattr(expr, 'op', False)
+ and expr.op in ['unary', 'binop', 'inplace_binop', 'getitem', 'static_getitem'])
+
+def is_get_setitem(stmt):
+ """stmt is getitem assignment or setitem (and static cases)"""
+ return is_getitem(stmt) or is_setitem(stmt)
+
+
+def is_getitem(stmt):
+ """true if stmt is a getitem or static_getitem assignment"""
+ return (isinstance(stmt, ir.Assign)
+ and isinstance(stmt.value, ir.Expr)
+ and stmt.value.op in ['getitem', 'static_getitem'])
+
+def is_setitem(stmt):
+ """true if stmt is a SetItem or StaticSetItem node"""
+ return isinstance(stmt, (ir.SetItem, ir.StaticSetItem))
+
+def index_var_of_get_setitem(stmt):
+ """get index variable for getitem/setitem nodes (and static cases)"""
+ if is_getitem(stmt):
+ if stmt.value.op == 'getitem':
+ return stmt.value.index
+ else:
+ return stmt.value.index_var
+
+ if is_setitem(stmt):
+ if isinstance(stmt, ir.SetItem):
+ return stmt.index
+ else:
+ return stmt.index_var
+
+ return None
+
+def set_index_var_of_get_setitem(stmt, new_index):
+ if is_getitem(stmt):
+ if stmt.value.op == 'getitem':
+ stmt.value.index = new_index
+ else:
+ stmt.value.index_var = new_index
+ elif is_setitem(stmt):
+ if isinstance(stmt, ir.SetItem):
+ stmt.index = new_index
+ else:
+ stmt.index_var = new_index
+ else:
+ raise ValueError("getitem or setitem node expected but received {}".format(
+ stmt))
+
+
+def is_namedtuple_class(c):
+ """check if c is a namedtuple class"""
+ if not isinstance(c, type):
+ return False
+ # should have only tuple as superclass
+ bases = c.__bases__
+ if len(bases) != 1 or bases[0] != tuple:
+ return False
+ # should have _make method
+ if not hasattr(c, '_make'):
+ return False
+ # should have _fields that is all string
+ fields = getattr(c, '_fields', None)
+ if not isinstance(fields, tuple):
+ return False
+ return all(isinstance(f, str) for f in fields)
+
+
+def fill_block_with_call(newblock, callee, label_next, inputs, outputs):
+ """Fill *newblock* to call *callee* with arguments listed in *inputs*.
+ The returned values are unwrapped into variables in *outputs*.
+ The block would then jump to *label_next*.
+ """
+ scope = newblock.scope
+ loc = newblock.loc
+
+ fn = ir.Const(value=callee, loc=loc)
+ fnvar = scope.make_temp(loc=loc)
+ newblock.append(ir.Assign(target=fnvar, value=fn, loc=loc))
+ # call
+ args = [scope.get_exact(name) for name in inputs]
+ callexpr = ir.Expr.call(func=fnvar, args=args, kws=(), loc=loc)
+ callres = scope.make_temp(loc=loc)
+ newblock.append(ir.Assign(target=callres, value=callexpr, loc=loc))
+ # unpack return value
+ for i, out in enumerate(outputs):
+ target = scope.get_exact(out)
+ getitem = ir.Expr.static_getitem(value=callres, index=i,
+ index_var=None, loc=loc)
+ newblock.append(ir.Assign(target=target, value=getitem, loc=loc))
+ # jump to next block
+ newblock.append(ir.Jump(target=label_next, loc=loc))
+ return newblock
+
+
+def fill_callee_prologue(block, inputs, label_next):
+ """
+ Fill a new block *block* that unwraps arguments using names in *inputs* and
+ then jumps to *label_next*.
+
+ Expected to use with *fill_block_with_call()*
+ """
+ scope = block.scope
+ loc = block.loc
+ # load args
+ args = [ir.Arg(name=k, index=i, loc=loc)
+ for i, k in enumerate(inputs)]
+ for aname, aval in zip(inputs, args):
+ tmp = ir.Var(scope=scope, name=aname, loc=loc)
+ block.append(ir.Assign(target=tmp, value=aval, loc=loc))
+ # jump to loop entry
+ block.append(ir.Jump(target=label_next, loc=loc))
+ return block
+
+
+def fill_callee_epilogue(block, outputs):
+ """
+ Fill a new block *block* to prepare the return values.
+ This block is the last block of the function.
+
+ Expected to use with *fill_block_with_call()*
+ """
+ scope = block.scope
+ loc = block.loc
+ # prepare tuples to return
+ vals = [scope.get_exact(name=name) for name in outputs]
+ tupexpr = ir.Expr.build_tuple(items=vals, loc=loc)
+ tup = scope.make_temp(loc=loc)
+ block.append(ir.Assign(target=tup, value=tupexpr, loc=loc))
+ # return
+ block.append(ir.Return(value=tup, loc=loc))
+ return block
+
+
+def find_outer_value(func_ir, var):
+ """Check if a variable is a global value, and return the value,
+ or raise GuardException otherwise.
+ """
+ dfn = get_definition(func_ir, var)
+ if isinstance(dfn, (ir.Global, ir.FreeVar)):
+ return dfn.value
+
+ if isinstance(dfn, ir.Expr) and dfn.op == 'getattr':
+ prev_val = find_outer_value(func_ir, dfn.value)
+ try:
+ val = getattr(prev_val, dfn.attr)
+ return val
+ except AttributeError:
+ raise GuardException
+
+ raise GuardException
+
+
+def raise_on_unsupported_feature(func_ir, typemap):
+ """
+ Helper function to walk IR and raise if it finds op codes
+ that are unsupported. Could be extended to cover IR sequences
+ as well as op codes. Intended use is to call it as a pipeline
+ stage just prior to lowering to prevent LoweringErrors for known
+ unsupported features.
+ """
+ gdb_calls = [] # accumulate calls to gdb/gdb_init
+
+ # issue 2195: check for excessively large tuples
+ for arg_name in func_ir.arg_names:
+ if arg_name in typemap and \
+ isinstance(typemap[arg_name], types.containers.UniTuple) and \
+ typemap[arg_name].count > 1000:
+ # Raise an exception when len(tuple) > 1000. The choice of this number (1000)
+ # was entirely arbitrary
+ msg = ("Tuple '{}' length must be smaller than 1000.\n"
+ "Large tuples lead to the generation of a prohibitively large "
+ "LLVM IR which causes excessive memory pressure "
+ "and large compile times.\n"
+ "As an alternative, the use of a 'list' is recommended in "
+ "place of a 'tuple' as lists do not suffer from this problem.".format(arg_name))
+ raise UnsupportedError(msg, func_ir.loc)
+
+ for blk in func_ir.blocks.values():
+ for stmt in blk.find_insts(ir.Assign):
+ # This raises on finding `make_function`
+ if isinstance(stmt.value, ir.Expr):
+ if stmt.value.op == 'make_function':
+ val = stmt.value
+
+ # See if the construct name can be refined
+ code = getattr(val, 'code', None)
+ if code is not None:
+ # check if this is a closure, the co_name will
+ # be the captured function name which is not
+ # useful so be explicit
+ if getattr(val, 'closure', None) is not None:
+ use = ''
+ expr = ''
+ else:
+ use = code.co_name
+ expr = '(%s) ' % use
+ else:
+ use = ''
+ expr = ''
+
+ msg = ("Numba encountered the use of a language "
+ "feature it does not support in this context: "
+ "%s (op code: make_function not supported). If "
+ "the feature is explicitly supported it is "
+ "likely that the result of the expression %s"
+ "is being used in an unsupported manner.") % \
+ (use, expr)
+ raise UnsupportedError(msg, stmt.value.loc)
+
+ # this checks for gdb initialization calls, only one is permitted
+ if isinstance(stmt.value, (ir.Global, ir.FreeVar)):
+ val = stmt.value
+ val = getattr(val, 'value', None)
+ if val is None:
+ continue
+
+ # check global function
+ found = False
+ if isinstance(val, pytypes.FunctionType):
+ found = val in {numba.gdb, numba.gdb_init}
+ if not found: # freevar bind to intrinsic
+ found = getattr(val, '_name', "") == "gdb_internal"
+ if found:
+ gdb_calls.append(stmt.loc) # report last seen location
+
+ # this checks that np. was called if view is called
+ if isinstance(stmt.value, ir.Expr):
+ if stmt.value.op == 'getattr' and stmt.value.attr == 'view':
+ var = stmt.value.value.name
+ if isinstance(typemap[var], types.Array):
+ continue
+ df = func_ir.get_definition(var)
+ cn = guard(find_callname, func_ir, df)
+ if cn and cn[1] == 'numpy':
+ ty = getattr(numpy, cn[0])
+ if (numpy.issubdtype(ty, numpy.integer) or
+ numpy.issubdtype(ty, numpy.floating)):
+ continue
+
+ vardescr = '' if var.startswith('$') else "'{}' ".format(var)
+ raise TypingError(
+ "'view' can only be called on NumPy dtypes, "
+ "try wrapping the variable {}with 'np.()'".
+ format(vardescr), loc=stmt.loc)
+
+ # checks for globals that are also reflected
+ if isinstance(stmt.value, ir.Global):
+ ty = typemap[stmt.target.name]
+ msg = ("The use of a %s type, assigned to variable '%s' in "
+ "globals, is not supported as globals are considered "
+ "compile-time constants and there is no known way to "
+ "compile a %s type as a constant.")
+ if (getattr(ty, 'reflected', False) or
+ isinstance(ty, (types.DictType, types.ListType))):
+ raise TypingError(msg % (ty, stmt.value.name, ty), loc=stmt.loc)
+
+ # checks for generator expressions (yield in use when func_ir has
+ # not been identified as a generator).
+ if isinstance(stmt.value, ir.Yield) and not func_ir.is_generator:
+ msg = "The use of generator expressions is unsupported."
+ raise UnsupportedError(msg, loc=stmt.loc)
+
+ # There is more than one call to function gdb/gdb_init
+ if len(gdb_calls) > 1:
+ msg = ("Calling either numba.gdb() or numba.gdb_init() more than once "
+ "in a function is unsupported (strange things happen!), use "
+ "numba.gdb_breakpoint() to create additional breakpoints "
+ "instead.\n\nRelevant documentation is available here:\n"
+ "https://numba.readthedocs.io/en/stable/user/troubleshoot.html"
+ "#using-numba-s-direct-gdb-bindings-in-nopython-mode\n\n"
+ "Conflicting calls found at:\n %s")
+ buf = '\n'.join([x.strformat() for x in gdb_calls])
+ raise UnsupportedError(msg % buf)
+
+
+def warn_deprecated(func_ir, typemap):
+ # first pass, just walk the type map
+ for name, ty in typemap.items():
+ # the Type Metaclass has a reflected member
+ if ty.reflected:
+ # if its an arg, report function call
+ if name.startswith('arg.'):
+ loc = func_ir.loc
+ arg = name.split('.')[1]
+ fname = func_ir.func_id.func_qualname
+ tyname = 'list' if isinstance(ty, types.List) else 'set'
+ url = ("https://numba.readthedocs.io/en/stable/reference/"
+ "deprecation.html#deprecation-of-reflection-for-list-and"
+ "-set-types")
+ msg = ("\nEncountered the use of a type that is scheduled for "
+ "deprecation: type 'reflected %s' found for argument "
+ "'%s' of function '%s'.\n\nFor more information visit "
+ "%s" % (tyname, arg, fname, url))
+ warnings.warn(NumbaPendingDeprecationWarning(msg, loc=loc))
+
+
+def resolve_func_from_module(func_ir, node):
+ """
+ This returns the python function that is being getattr'd from a module in
+ some IR, it resolves import chains/submodules recursively. Should it not be
+ possible to find the python function being called None will be returned.
+
+ func_ir - the FunctionIR object
+ node - the IR node from which to start resolving (should be a `getattr`).
+ """
+ getattr_chain = []
+ def resolve_mod(mod):
+ if getattr(mod, 'op', False) == 'getattr':
+ getattr_chain.insert(0, mod.attr)
+ try:
+ mod = func_ir.get_definition(mod.value)
+ except KeyError: # multiple definitions
+ return None
+ return resolve_mod(mod)
+ elif isinstance(mod, (ir.Global, ir.FreeVar)):
+ if isinstance(mod.value, pytypes.ModuleType):
+ return mod
+ return None
+
+ mod = resolve_mod(node)
+ if mod is not None:
+ defn = mod.value
+ for x in getattr_chain:
+ defn = getattr(defn, x, False)
+ if not defn:
+ break
+ else:
+ return defn
+ else:
+ return None
+
+
+def enforce_no_dels(func_ir):
+ """
+ Enforce there being no ir.Del nodes in the IR.
+ """
+ for blk in func_ir.blocks.values():
+ dels = [x for x in blk.find_insts(ir.Del)]
+ if dels:
+ msg = "Illegal IR, del found at: %s" % dels[0]
+ raise CompilerError(msg, loc=dels[0].loc)
+
+def enforce_no_phis(func_ir):
+ """
+ Enforce there being no ir.Expr.phi nodes in the IR.
+ """
+ for blk in func_ir.blocks.values():
+ phis = [x for x in blk.find_exprs(op='phi')]
+ if phis:
+ msg = "Illegal IR, phi found at: %s" % phis[0]
+ raise CompilerError(msg, loc=phis[0].loc)
+
+
+def legalize_single_scope(blocks):
+ """Check the given mapping of ir.Block for containing a single scope.
+ """
+ return len({blk.scope for blk in blocks.values()}) == 1
+
+
+def check_and_legalize_ir(func_ir, flags: "numba.core.compiler.Flags"):
+ """
+ This checks that the IR presented is legal
+ """
+ enforce_no_phis(func_ir)
+ enforce_no_dels(func_ir)
+ # postprocess and emit ir.Dels
+ post_proc = postproc.PostProcessor(func_ir)
+ post_proc.run(True, extend_lifetimes=flags.dbg_extend_lifetimes)
+
+def convert_code_obj_to_function(code_obj, caller_ir):
+ """
+ Converts a code object from a `make_function.code` attr in the IR into a
+ python function, caller_ir is the FunctionIR of the caller and is used for
+ the resolution of freevars.
+ """
+ fcode = code_obj.code
+ nfree = len(fcode.co_freevars)
+
+ # try and resolve freevars if they are consts in the caller's IR
+ # these can be baked into the new function
+ freevars = []
+ for x in fcode.co_freevars:
+ # not using guard here to differentiate between multiple definition and
+ # non-const variable
+ try:
+ freevar_def = caller_ir.get_definition(x)
+ except KeyError:
+ msg = ("Cannot capture a constant value for variable '%s' as there "
+ "are multiple definitions present." % x)
+ raise TypingError(msg, loc=code_obj.loc)
+ if isinstance(freevar_def, ir.Const):
+ freevars.append(freevar_def.value)
+ else:
+ msg = ("Cannot capture the non-constant value associated with "
+ "variable '%s' in a function that may escape." % x)
+ raise TypingError(msg, loc=code_obj.loc)
+
+ func_env = "\n".join(["\tc_%d = %s" % (i, x) for i, x in enumerate(freevars)])
+ func_clo = ",".join(["c_%d" % i for i in range(nfree)])
+ co_varnames = list(fcode.co_varnames)
+
+ # This is horrible. The code object knows about the number of args present
+ # it also knows the name of the args but these are bundled in with other
+ # vars in `co_varnames`. The make_function IR node knows what the defaults
+ # are, they are defined in the IR as consts. The following finds the total
+ # number of args (args + kwargs with defaults), finds the default values
+ # and infers the number of "kwargs with defaults" from this and then infers
+ # the number of actual arguments from that.
+ n_kwargs = 0
+ n_allargs = fcode.co_argcount
+ kwarg_defaults = caller_ir.get_definition(code_obj.defaults)
+ if kwarg_defaults is not None:
+ if isinstance(kwarg_defaults, tuple):
+ d = [caller_ir.get_definition(x).value for x in kwarg_defaults]
+ kwarg_defaults_tup = tuple(d)
+ else:
+ d = [caller_ir.get_definition(x).value
+ for x in kwarg_defaults.items]
+ kwarg_defaults_tup = tuple(d)
+ n_kwargs = len(kwarg_defaults_tup)
+ nargs = n_allargs - n_kwargs
+
+ func_arg = ",".join(["%s" % (co_varnames[i]) for i in range(nargs)])
+ if n_kwargs:
+ kw_const = ["%s = %s" % (co_varnames[i + nargs], kwarg_defaults_tup[i])
+ for i in range(n_kwargs)]
+ func_arg += ", "
+ func_arg += ", ".join(kw_const)
+
+ # globals are the same as those in the caller
+ glbls = caller_ir.func_id.func.__globals__
+
+ # create the function and return it
+ return _create_function_from_code_obj(fcode, func_env, func_arg, func_clo,
+ glbls)
+
+
+def fixup_var_define_in_scope(blocks):
+ """Fixes the mapping of ir.Block to ensure all referenced ir.Var are
+ defined in every scope used by the function. Such that looking up a variable
+ from any scope in this function will not fail.
+
+ Note: This is a workaround. Ideally, all the blocks should refer to the
+ same ir.Scope, but that property is not maintained by all the passes.
+ """
+ # Scan for all used variables
+ used_var = {}
+ for blk in blocks.values():
+ scope = blk.scope
+ for inst in blk.body:
+ for var in inst.list_vars():
+ used_var[var] = inst
+ # Note: not all blocks share a single scope even though they should.
+ # Ensure the scope of each block defines all used variables.
+ for blk in blocks.values():
+ scope = blk.scope
+ for var, inst in used_var.items():
+ # add this variable if it's not in scope
+ if var.name not in scope.localvars:
+ # Note: using a internal method to reuse the same
+ scope.localvars.define(var.name, var)
+
+
+def transfer_scope(block, scope):
+ """Transfer the ir.Block to use the given ir.Scope.
+ """
+ old_scope = block.scope
+ if old_scope is scope:
+ # bypass if the block is already using the given scope
+ return block
+ # Ensure variables are defined in the new scope
+ for var in old_scope.localvars._con.values():
+ if var.name not in scope.localvars:
+ scope.localvars.define(var.name, var)
+ # replace scope
+ block.scope = scope
+ return block
+
+
+def is_setup_with(stmt):
+ return isinstance(stmt, ir.EnterWith)
+
+
+def is_terminator(stmt):
+ return isinstance(stmt, ir.Terminator)
+
+
+def is_raise(stmt):
+ return isinstance(stmt, ir.Raise)
+
+
+def is_return(stmt):
+ return isinstance(stmt, ir.Return)
+
+
+def is_pop_block(stmt):
+ return isinstance(stmt, ir.PopBlock)
diff --git a/venv/lib/python3.10/site-packages/numba/core/itanium_mangler.py b/venv/lib/python3.10/site-packages/numba/core/itanium_mangler.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fb55ee5ac31f267e16ff66bb22d99c625594a7b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/itanium_mangler.py
@@ -0,0 +1,225 @@
+"""
+Itanium CXX ABI Mangler
+
+Reference: https://itanium-cxx-abi.github.io/cxx-abi/abi.html
+
+The basics of the mangling scheme.
+
+We are hijacking the CXX mangling scheme for our use. We map Python modules
+into CXX namespace. A `module1.submodule2.foo` is mapped to
+`module1::submodule2::foo`. For parameterized numba types, we treat them as
+templated types; for example, `array(int64, 1d, C)` becomes an
+`array`.
+
+All mangled names are prefixed with "_Z". It is followed by the name of the
+entity. A name contains one or more identifiers. Each identifier is encoded
+as "". If the name is namespaced and, therefore,
+has multiple identifiers, the entire name is encoded as "NE".
+
+For functions, arguments types follow. There are condensed encodings for basic
+built-in types; e.g. "i" for int, "f" for float. For other types, the
+previously mentioned name encoding should be used.
+
+For templated types, the template parameters are encoded immediately after the
+name. If it is namespaced, it should be within the 'N' 'E' marker. Template
+parameters are encoded in "IE", where each parameter is encoded using
+the mentioned name encoding scheme. Template parameters can contain literal
+values like the '1' in the array type shown earlier. There is special encoding
+scheme for them to avoid leading digits.
+"""
+
+
+import re
+
+from numba.core import types, config
+
+
+# According the scheme, valid characters for mangled names are [a-zA-Z0-9_].
+# We borrow the '_' as the escape character to encode invalid char into
+# '_xx' where 'xx' is the hex codepoint.
+_re_invalid_char = re.compile(r'[^a-z0-9_]', re.I)
+
+PREFIX = "_Z"
+
+# Numba types to mangled type code. These correspond with the codes listed in
+# https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-builtin
+if config.USE_LEGACY_TYPE_SYSTEM: # Old type system
+ N2CODE = {
+ types.void: 'v',
+ types.boolean: 'b',
+ types.uint8: 'h',
+ types.int8: 'a',
+ types.uint16: 't',
+ types.int16: 's',
+ types.uint32: 'j',
+ types.int32: 'i',
+ types.uint64: 'y',
+ types.int64: 'x',
+ types.float16: 'Dh',
+ types.float32: 'f',
+ types.float64: 'd'
+ }
+else:
+ N2CODE = {
+ types.void: 'v',
+ types.py_bool: 'b',
+ types.py_int: 'x',
+ types.py_float: 'd',
+ types.np_bool_: 'b',
+ types.np_uint8: 'h',
+ types.np_int8: 'a',
+ types.np_uint16: 't',
+ types.np_int16: 's',
+ types.np_uint32: 'j',
+ types.np_int32: 'i',
+ types.np_uint64: 'y',
+ types.np_int64: 'x',
+ types.np_float16: 'Dh',
+ types.np_float32: 'f',
+ types.np_float64: 'd'
+ }
+
+
+def _escape_string(text):
+ """Escape the given string so that it only contains ASCII characters
+ of [a-zA-Z0-9_$].
+
+ The dollar symbol ($) and other invalid characters are escaped into
+ the string sequence of "$xx" where "xx" is the hex codepoint of the char.
+
+ Multibyte characters are encoded into utf8 and converted into the above
+ hex format.
+ """
+
+ def repl(m):
+ return ''.join(('_%02x' % ch)
+ for ch in m.group(0).encode('utf8'))
+ ret = re.sub(_re_invalid_char, repl, text)
+ # Return str if we got a unicode (for py2)
+ if not isinstance(ret, str):
+ return ret.encode('ascii')
+ return ret
+
+
+def _fix_lead_digit(text):
+ """
+ Fix text with leading digit
+ """
+ if text and text[0].isdigit():
+ return '_' + text
+ else:
+ return text
+
+
+def _len_encoded(string):
+ """
+ Prefix string with digit indicating the length.
+ Add underscore if string is prefixed with digits.
+ """
+ string = _fix_lead_digit(string)
+ return '%u%s' % (len(string), string)
+
+
+def mangle_abi_tag(abi_tag: str) -> str:
+ return "B" + _len_encoded(_escape_string(abi_tag))
+
+
+def mangle_identifier(ident, template_params='', *, abi_tags=(), uid=None):
+ """
+ Mangle the identifier with optional template parameters and abi_tags.
+
+ Note:
+
+ This treats '.' as '::' in C++.
+ """
+ if uid is not None:
+ # Add uid to abi-tags
+ abi_tags = (f"v{uid}", *abi_tags)
+ parts = [_len_encoded(_escape_string(x)) for x in ident.split('.')]
+ enc_abi_tags = list(map(mangle_abi_tag, abi_tags))
+ extras = template_params + ''.join(enc_abi_tags)
+ if len(parts) > 1:
+ return 'N%s%sE' % (''.join(parts), extras)
+ else:
+ return '%s%s' % (parts[0], extras)
+
+
+def mangle_type_or_value(typ):
+ """
+ Mangle type parameter and arbitrary value.
+ """
+ # Handle numba types
+ if isinstance(typ, types.Type):
+ if typ in N2CODE:
+ return N2CODE[typ]
+ else:
+ return mangle_templated_ident(*typ.mangling_args)
+ # Handle integer literal
+ elif isinstance(typ, int):
+ return 'Li%dE' % typ
+ # Handle str as identifier
+ elif isinstance(typ, str):
+ return mangle_identifier(typ)
+ # Otherwise
+ else:
+ enc = _escape_string(str(typ))
+ return _len_encoded(enc)
+
+
+# Alias
+mangle_type = mangle_type_or_value
+mangle_value = mangle_type_or_value
+
+
+def mangle_templated_ident(identifier, parameters):
+ """
+ Mangle templated identifier.
+ """
+ template_params = ('I%sE' % ''.join(map(mangle_type_or_value, parameters))
+ if parameters else '')
+ return mangle_identifier(identifier, template_params)
+
+
+def mangle_args(argtys):
+ """
+ Mangle sequence of Numba type objects and arbitrary values.
+ """
+ return ''.join([mangle_type_or_value(t) for t in argtys])
+
+
+def mangle(ident, argtys, *, abi_tags=(), uid=None):
+ """
+ Mangle identifier with Numba type objects and abi-tags.
+ """
+ return ''.join([PREFIX,
+ mangle_identifier(ident, abi_tags=abi_tags, uid=uid),
+ mangle_args(argtys)])
+
+
+def prepend_namespace(mangled, ns):
+ """
+ Prepend namespace to mangled name.
+ """
+ if not mangled.startswith(PREFIX):
+ raise ValueError('input is not a mangled name')
+ elif mangled.startswith(PREFIX + 'N'):
+ # nested
+ remaining = mangled[3:]
+ ret = PREFIX + 'N' + mangle_identifier(ns) + remaining
+ else:
+ # non-nested
+ remaining = mangled[2:]
+ head, tail = _split_mangled_ident(remaining)
+ ret = PREFIX + 'N' + mangle_identifier(ns) + head + 'E' + tail
+ return ret
+
+
+def _split_mangled_ident(mangled):
+ """
+ Returns `(head, tail)` where `head` is the ` + ` encoded
+ identifier and `tail` is the remaining.
+ """
+ ct = int(mangled)
+ ctlen = len(str(ct))
+ at = ctlen + ct
+ return mangled[:at], mangled[at:]
diff --git a/venv/lib/python3.10/site-packages/numba/core/llvm_bindings.py b/venv/lib/python3.10/site-packages/numba/core/llvm_bindings.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa94ad428b45088e6e9b685ac2766234e9c6cc06
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/llvm_bindings.py
@@ -0,0 +1,46 @@
+"""
+Useful options to debug LLVM passes
+
+llvm.set_option("test", "-debug-pass=Details")
+llvm.set_option("test", "-debug-pass=Executions")
+llvm.set_option("test", "-debug-pass=Arguments")
+llvm.set_option("test", "-debug-pass=Structure")
+llvm.set_option("test", "-debug-only=loop-vectorize")
+llvm.set_option("test", "-help-hidden")
+
+"""
+
+from llvmlite import binding as llvm
+
+
+def _inlining_threshold(optlevel, sizelevel=0):
+ """
+ Compute the inlining threshold for the desired optimisation level
+
+ Refer to http://llvm.org/docs/doxygen/html/InlineSimple_8cpp_source.html
+ """
+ if optlevel > 2:
+ return 275
+
+ # -Os
+ if sizelevel == 1:
+ return 75
+
+ # -Oz
+ if sizelevel == 2:
+ return 25
+
+ return 225
+
+
+def create_pass_manager_builder(opt=2, loop_vectorize=False,
+ slp_vectorize=False):
+ """
+ Create an LLVM pass manager with the desired optimisation level and options.
+ """
+ pmb = llvm.create_pass_manager_builder()
+ pmb.opt_level = opt
+ pmb.loop_vectorize = loop_vectorize
+ pmb.slp_vectorize = slp_vectorize
+ pmb.inlining_threshold = _inlining_threshold(opt)
+ return pmb
diff --git a/venv/lib/python3.10/site-packages/numba/core/lowering.py b/venv/lib/python3.10/site-packages/numba/core/lowering.py
new file mode 100644
index 0000000000000000000000000000000000000000..071f46fbe1b183bd2436a6758262ba8234c289d6
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/lowering.py
@@ -0,0 +1,1652 @@
+from collections import namedtuple, defaultdict
+import operator
+import warnings
+from functools import partial
+
+import llvmlite.ir
+from llvmlite.ir import Constant, IRBuilder
+
+from numba.core import (typing, utils, types, ir, debuginfo, funcdesc,
+ generators, config, ir_utils, cgutils, removerefctpass,
+ targetconfig)
+from numba.core.errors import (LoweringError, new_error_context, TypingError,
+ LiteralTypingError, UnsupportedError,
+ NumbaDebugInfoWarning)
+from numba.core.funcdesc import default_mangler
+from numba.core.environment import Environment
+from numba.core.analysis import compute_use_defs, must_use_alloca
+from numba.misc.firstlinefinder import get_func_body_first_lineno
+from numba.misc.coverage_support import get_registered_loc_notify
+
+
+_VarArgItem = namedtuple("_VarArgItem", ("vararg", "index"))
+
+
+class BaseLower(object):
+ """
+ Lower IR to LLVM
+ """
+
+ def __init__(self, context, library, fndesc, func_ir, metadata=None):
+ self.library = library
+ self.fndesc = fndesc
+ self.blocks = utils.SortedMap(func_ir.blocks.items())
+ self.func_ir = func_ir
+ self.generator_info = func_ir.generator_info
+ self.metadata = metadata
+ self.flags = targetconfig.ConfigStack.top_or_none()
+
+ # Initialize LLVM
+ self.module = self.library.create_ir_module(self.fndesc.unique_name)
+
+ # Python execution environment (will be available to the compiled
+ # function).
+ self.env = Environment.from_fndesc(self.fndesc)
+
+ # Internal states
+ self.blkmap = {}
+ self.pending_phis = {}
+ self.varmap = {}
+ self.firstblk = min(self.blocks.keys())
+ self.loc = -1
+
+ # Specializes the target context as seen inside the Lowerer
+ # This adds:
+ # - environment: the python execution environment
+ self.context = context.subtarget(environment=self.env,
+ fndesc=self.fndesc)
+
+ # Debuginfo
+ dibuildercls = (self.context.DIBuilder
+ if self.context.enable_debuginfo
+ else debuginfo.DummyDIBuilder)
+
+ # debuginfo def location
+ self.defn_loc = self._compute_def_location()
+
+ directives_only = self.flags.dbg_directives_only
+ self.debuginfo = dibuildercls(module=self.module,
+ filepath=func_ir.loc.filename,
+ cgctx=context,
+ directives_only=directives_only)
+
+ # Loc notify objects
+ self._loc_notify_registry = get_registered_loc_notify()
+
+ # Subclass initialization
+ self.init()
+
+ @property
+ def call_conv(self):
+ return self.context.call_conv
+
+ def init(self):
+ pass
+
+ def init_pyapi(self):
+ """
+ Init the Python API and Environment Manager for the function being
+ lowered.
+ """
+ if self.pyapi is not None:
+ return
+ self.pyapi = self.context.get_python_api(self.builder)
+
+ # Store environment argument for later use
+ self.env_manager = self.context.get_env_manager(self.builder)
+ self.env_body = self.env_manager.env_body
+ self.envarg = self.env_manager.env_ptr
+
+ def _compute_def_location(self):
+ # Debuginfo requires source to be accurate. Find it and warn if not
+ # found. If it's not found, use the func_ir line + 1, this assumes that
+ # the function definition is decorated with a 1 line jit decorator.
+ defn_loc = self.func_ir.loc.with_lineno(self.func_ir.loc.line + 1)
+ if self.context.enable_debuginfo:
+ fn = self.func_ir.func_id.func
+ optional_lno = get_func_body_first_lineno(fn)
+ if optional_lno is not None:
+ # -1 as lines start at 1 and this is an offset.
+ offset = optional_lno - 1
+ defn_loc = self.func_ir.loc.with_lineno(offset)
+ else:
+ msg = ("Could not find source for function: "
+ f"{self.func_ir.func_id.func}. Debug line information "
+ "may be inaccurate.")
+ warnings.warn(NumbaDebugInfoWarning(msg))
+ return defn_loc
+
+ def pre_lower(self):
+ """
+ Called before lowering all blocks.
+ """
+ # A given Lower object can be used for several LL functions
+ # (for generators) and it's important to use a new API and
+ # EnvironmentManager.
+ self.pyapi = None
+ self.debuginfo.mark_subprogram(function=self.builder.function,
+ qualname=self.fndesc.qualname,
+ argnames=self.fndesc.args,
+ argtypes=self.fndesc.argtypes,
+ line=self.defn_loc.line)
+
+ # When full debug info is enabled, disable inlining where possible, to
+ # improve the quality of the debug experience. 'alwaysinline' functions
+ # cannot have inlining disabled.
+ attributes = self.builder.function.attributes
+ full_debug = self.flags.debuginfo and not self.flags.dbg_directives_only
+ if full_debug and 'alwaysinline' not in attributes:
+ attributes.add('noinline')
+
+ def post_lower(self):
+ """
+ Called after all blocks are lowered
+ """
+ self.debuginfo.finalize()
+ for notify in self._loc_notify_registry:
+ notify.close()
+
+ def pre_block(self, block):
+ """
+ Called before lowering a block.
+ """
+
+ def post_block(self, block):
+ """
+ Called after lowering a block.
+ """
+
+ def return_dynamic_exception(self, exc_class, exc_args, nb_types, loc=None):
+ self.call_conv.return_dynamic_user_exc(
+ self.builder, exc_class, exc_args, nb_types,
+ loc=loc, func_name=self.func_ir.func_id.func_name,
+ )
+
+ def return_exception(self, exc_class, exc_args=None, loc=None):
+ """Propagate exception to the caller.
+ """
+ self.call_conv.return_user_exc(
+ self.builder, exc_class, exc_args,
+ loc=loc, func_name=self.func_ir.func_id.func_name,
+ )
+
+ def set_exception(self, exc_class, exc_args=None, loc=None):
+ """Set exception state in the current function.
+ """
+ self.call_conv.set_static_user_exc(
+ self.builder, exc_class, exc_args,
+ loc=loc, func_name=self.func_ir.func_id.func_name,
+ )
+
+ def emit_environment_object(self):
+ """Emit a pointer to hold the Environment object.
+ """
+ # Define global for the environment and initialize it to NULL
+ envname = self.context.get_env_name(self.fndesc)
+ self.context.declare_env_global(self.module, envname)
+
+ def lower(self):
+ # Emit the Env into the module
+ self.emit_environment_object()
+ if self.generator_info is None:
+ self.genlower = None
+ self.lower_normal_function(self.fndesc)
+ else:
+ self.genlower = self.GeneratorLower(self)
+ self.gentype = self.genlower.gentype
+
+ self.genlower.lower_init_func(self)
+ self.genlower.lower_next_func(self)
+ if self.gentype.has_finalizer:
+ self.genlower.lower_finalize_func(self)
+
+ if config.DUMP_LLVM:
+ utils.dump_llvm(self.fndesc, self.module)
+
+ # Special optimization to remove NRT on functions that do not need it.
+ if self.context.enable_nrt and self.generator_info is None:
+ removerefctpass.remove_unnecessary_nrt_usage(self.function,
+ context=self.context,
+ fndesc=self.fndesc)
+
+ # Run target specific post lowering transformation
+ self.context.post_lowering(self.module, self.library)
+
+ # Materialize LLVM Module
+ self.library.add_ir_module(self.module)
+
+ def extract_function_arguments(self):
+ self.fnargs = self.call_conv.decode_arguments(self.builder,
+ self.fndesc.argtypes,
+ self.function)
+ return self.fnargs
+
+ def lower_normal_function(self, fndesc):
+ """
+ Lower non-generator *fndesc*.
+ """
+ self.setup_function(fndesc)
+
+ # Init argument values
+ self.extract_function_arguments()
+ entry_block_tail = self.lower_function_body()
+
+ # Close tail of entry block, do not emit debug metadata else the
+ # unconditional jump gets associated with the metadata from the function
+ # body end.
+ with debuginfo.suspend_emission(self.builder):
+ self.builder.position_at_end(entry_block_tail)
+ self.builder.branch(self.blkmap[self.firstblk])
+
+ def lower_function_body(self):
+ """
+ Lower the current function's body, and return the entry block.
+ """
+ # Init Python blocks
+ for offset in self.blocks:
+ bname = "B%s" % offset
+ self.blkmap[offset] = self.function.append_basic_block(bname)
+
+ self.pre_lower()
+ # pre_lower() may have changed the current basic block
+ entry_block_tail = self.builder.basic_block
+
+ self.debug_print("# function begin: {0}".format(
+ self.fndesc.unique_name))
+
+ # Lower all blocks
+ for offset, block in sorted(self.blocks.items()):
+ bb = self.blkmap[offset]
+ self.builder.position_at_end(bb)
+ self.debug_print(f"# lower block: {offset}")
+ self.lower_block(block)
+ self.post_lower()
+ return entry_block_tail
+
+ def lower_block(self, block):
+ """
+ Lower the given block.
+ """
+ self.pre_block(block)
+ for inst in block.body:
+ self.loc = inst.loc
+ defaulterrcls = partial(LoweringError, loc=self.loc)
+ with new_error_context('lowering "{inst}" at {loc}', inst=inst,
+ loc=self.loc, errcls_=defaulterrcls):
+ self.lower_inst(inst)
+ self.post_block(block)
+
+ def create_cpython_wrapper(self, release_gil=False):
+ """
+ Create CPython wrapper(s) around this function (or generator).
+ """
+ if self.genlower:
+ self.context.create_cpython_wrapper(self.library,
+ self.genlower.gendesc,
+ self.env, self.call_helper,
+ release_gil=release_gil)
+ self.context.create_cpython_wrapper(self.library, self.fndesc,
+ self.env, self.call_helper,
+ release_gil=release_gil)
+
+ def create_cfunc_wrapper(self):
+ """
+ Create C wrapper around this function.
+ """
+ if self.genlower:
+ raise UnsupportedError('generator as a first-class function type')
+ self.context.create_cfunc_wrapper(self.library, self.fndesc,
+ self.env, self.call_helper)
+
+ def setup_function(self, fndesc):
+ # Setup function
+ self.function = self.context.declare_function(self.module, fndesc)
+ if self.flags.dbg_optnone:
+ attrset = self.function.attributes
+ if "alwaysinline" not in attrset:
+ attrset.add("optnone")
+ attrset.add("noinline")
+ self.entry_block = self.function.append_basic_block('entry')
+ self.builder = IRBuilder(self.entry_block)
+ self.call_helper = self.call_conv.init_call_helper(self.builder)
+
+ def typeof(self, varname):
+ return self.fndesc.typemap[varname]
+
+ def notify_loc(self, loc: ir.Loc) -> None:
+ """Called when a new instruction with the given `loc` is about to be
+ lowered.
+ """
+ for notify_obj in self._loc_notify_registry:
+ notify_obj.notify(loc)
+
+ def debug_print(self, msg):
+ if config.DEBUG_JIT:
+ self.context.debug_print(
+ self.builder, f"DEBUGJIT [{self.fndesc.qualname}]: {msg}")
+
+ def print_variable(self, msg, varname):
+ """Helper to emit ``print(msg, varname)`` for debugging.
+
+ Parameters
+ ----------
+ msg : str
+ Literal string to be printed.
+ varname : str
+ A variable name whose value will be printed.
+ """
+ argtys = (
+ types.literal(msg),
+ self.fndesc.typemap[varname]
+ )
+ args = (
+ self.context.get_dummy_value(),
+ self.loadvar(varname),
+ )
+ sig = typing.signature(types.none, *argtys)
+
+ impl = self.context.get_function(print, sig)
+ impl(self.builder, args)
+
+
+class Lower(BaseLower):
+ GeneratorLower = generators.GeneratorLower
+
+ def init(self):
+ super().init()
+ # find all singly assigned variables
+ self._find_singly_assigned_variable()
+
+ @property
+ def _disable_sroa_like_opt(self):
+ """Flags that the SROA like optimisation that Numba performs (which
+ prevent alloca and subsequent load/store for locals) should be disabled.
+ Currently, this is conditional solely on the presence of a request for
+ the emission of debug information."""
+ if self.flags is None:
+ return False
+
+ return self.flags.debuginfo and not self.flags.dbg_directives_only
+
+ def _find_singly_assigned_variable(self):
+ func_ir = self.func_ir
+ blocks = func_ir.blocks
+
+ sav = set()
+
+ if not self.func_ir.func_id.is_generator:
+ use_defs = compute_use_defs(blocks)
+ alloca_vars = must_use_alloca(blocks)
+
+ # Compute where variables are defined
+ var_assign_map = defaultdict(set)
+ for blk, vl in use_defs.defmap.items():
+ for var in vl:
+ var_assign_map[var].add(blk)
+
+ # Compute where variables are used
+ var_use_map = defaultdict(set)
+ for blk, vl in use_defs.usemap.items():
+ for var in vl:
+ var_use_map[var].add(blk)
+
+ # Keep only variables that are defined locally and used locally
+ for var in var_assign_map:
+ if var not in alloca_vars and len(var_assign_map[var]) == 1:
+ # Usemap does not keep locally defined variables.
+ if len(var_use_map[var]) == 0:
+ # Ensure that the variable is not defined multiple times
+ # in the block
+ [defblk] = var_assign_map[var]
+ assign_stmts = self.blocks[defblk].find_insts(ir.Assign)
+ assigns = [stmt for stmt in assign_stmts
+ if stmt.target.name == var]
+ if len(assigns) == 1:
+ sav.add(var)
+
+ self._singly_assigned_vars = sav
+ self._blk_local_varmap = {}
+
+ def pre_block(self, block):
+ from numba.core.unsafe import eh
+
+ super(Lower, self).pre_block(block)
+ self._cur_ir_block = block
+
+ if block == self.firstblk:
+ # create slots for all the vars, irrespective of whether they are
+ # initialized, SSA will pick this up and warn users about using
+ # uninitialized variables. Slots are added as alloca in the first
+ # block
+ bb = self.blkmap[self.firstblk]
+ self.builder.position_at_end(bb)
+ all_names = set()
+ for block in self.blocks.values():
+ for x in block.find_insts(ir.Del):
+ if x.value not in all_names:
+ all_names.add(x.value)
+ for name in all_names:
+ fetype = self.typeof(name)
+ self._alloca_var(name, fetype)
+
+ # Detect if we are in a TRY block by looking for a call to
+ # `eh.exception_check`.
+ for call in block.find_exprs(op='call'):
+ defn = ir_utils.guard(
+ ir_utils.get_definition, self.func_ir, call.func,
+ )
+ if defn is not None and isinstance(defn, ir.Global):
+ if defn.value is eh.exception_check:
+ if isinstance(block.terminator, ir.Branch):
+ targetblk = self.blkmap[block.terminator.truebr]
+ # NOTE: This hacks in an attribute for call_conv to
+ # pick up. This hack is no longer needed when
+ # all old-style implementations are gone.
+ self.builder._in_try_block = {'target': targetblk}
+ break
+
+ def post_block(self, block):
+ # Clean-up
+ try:
+ del self.builder._in_try_block
+ except AttributeError:
+ pass
+
+ def lower_inst(self, inst):
+ # Set debug location for all subsequent LL instructions
+ self.debuginfo.mark_location(self.builder, self.loc.line)
+ self.notify_loc(self.loc)
+ self.debug_print(str(inst))
+ if isinstance(inst, ir.Assign):
+ ty = self.typeof(inst.target.name)
+ val = self.lower_assign(ty, inst)
+ argidx = None
+ # If this is a store from an arg, like x = arg.x then tell debuginfo
+ # that this is the arg
+ if isinstance(inst.value, ir.Arg):
+ # NOTE: debug location is the `def ` line
+ self.debuginfo.mark_location(self.builder, self.defn_loc.line)
+ argidx = inst.value.index + 1 # args start at 1
+ self.storevar(val, inst.target.name, argidx=argidx)
+
+ elif isinstance(inst, ir.Branch):
+ cond = self.loadvar(inst.cond.name)
+ tr = self.blkmap[inst.truebr]
+ fl = self.blkmap[inst.falsebr]
+
+ condty = self.typeof(inst.cond.name)
+ pred = self.context.cast(self.builder, cond, condty, types.boolean)
+ assert pred.type == llvmlite.ir.IntType(1),\
+ ("cond is not i1: %s" % pred.type)
+ self.builder.cbranch(pred, tr, fl)
+
+ elif isinstance(inst, ir.Jump):
+ target = self.blkmap[inst.target]
+ self.builder.branch(target)
+
+ elif isinstance(inst, ir.Return):
+ if self.generator_info:
+ # StopIteration
+ self.genlower.return_from_generator(self)
+ return
+ val = self.loadvar(inst.value.name)
+ oty = self.typeof(inst.value.name)
+ ty = self.fndesc.restype
+ if isinstance(ty, types.Optional):
+ # If returning an optional type
+ self.call_conv.return_optional_value(self.builder, ty, oty, val)
+ return
+ assert ty == oty, (
+ "type '{}' does not match return type '{}'".format(oty, ty))
+ retval = self.context.get_return_value(self.builder, ty, val)
+ self.call_conv.return_value(self.builder, retval)
+
+ elif isinstance(inst, ir.PopBlock):
+ pass # this is just a marker
+
+ elif isinstance(inst, ir.StaticSetItem):
+ signature = self.fndesc.calltypes[inst]
+ assert signature is not None
+ try:
+ impl = self.context.get_function('static_setitem', signature)
+ except NotImplementedError:
+ return self.lower_setitem(inst.target, inst.index_var,
+ inst.value, signature)
+ else:
+ target = self.loadvar(inst.target.name)
+ value = self.loadvar(inst.value.name)
+ valuety = self.typeof(inst.value.name)
+ value = self.context.cast(self.builder, value, valuety,
+ signature.args[2])
+ return impl(self.builder, (target, inst.index, value))
+
+ elif isinstance(inst, ir.Print):
+ self.lower_print(inst)
+
+ elif isinstance(inst, ir.SetItem):
+ signature = self.fndesc.calltypes[inst]
+ assert signature is not None
+ return self.lower_setitem(inst.target, inst.index, inst.value,
+ signature)
+
+ elif isinstance(inst, ir.StoreMap):
+ signature = self.fndesc.calltypes[inst]
+ assert signature is not None
+ return self.lower_setitem(inst.dct, inst.key, inst.value, signature)
+
+ elif isinstance(inst, ir.DelItem):
+ target = self.loadvar(inst.target.name)
+ index = self.loadvar(inst.index.name)
+
+ targetty = self.typeof(inst.target.name)
+ indexty = self.typeof(inst.index.name)
+
+ signature = self.fndesc.calltypes[inst]
+ assert signature is not None
+
+ op = operator.delitem
+ fnop = self.context.typing_context.resolve_value_type(op)
+ callsig = fnop.get_call_type(
+ self.context.typing_context, signature.args, {},
+ )
+ impl = self.context.get_function(fnop, callsig)
+
+ assert targetty == signature.args[0]
+ index = self.context.cast(self.builder, index, indexty,
+ signature.args[1])
+
+ return impl(self.builder, (target, index))
+
+ elif isinstance(inst, ir.Del):
+ self.delvar(inst.value)
+
+ elif isinstance(inst, ir.SetAttr):
+ target = self.loadvar(inst.target.name)
+ value = self.loadvar(inst.value.name)
+ signature = self.fndesc.calltypes[inst]
+
+ targetty = self.typeof(inst.target.name)
+ valuety = self.typeof(inst.value.name)
+ assert signature is not None
+ assert signature.args[0] == targetty
+ impl = self.context.get_setattr(inst.attr, signature)
+
+ # Convert argument to match
+ value = self.context.cast(self.builder, value, valuety,
+ signature.args[1])
+
+ return impl(self.builder, (target, value))
+
+ elif isinstance(inst, ir.DynamicRaise):
+ self.lower_dynamic_raise(inst)
+
+ elif isinstance(inst, ir.DynamicTryRaise):
+ self.lower_try_dynamic_raise(inst)
+
+ elif isinstance(inst, ir.StaticRaise):
+ self.lower_static_raise(inst)
+
+ elif isinstance(inst, ir.StaticTryRaise):
+ self.lower_static_try_raise(inst)
+
+ else:
+ raise NotImplementedError(type(inst))
+
+ def lower_setitem(self, target_var, index_var, value_var, signature):
+ target = self.loadvar(target_var.name)
+ value = self.loadvar(value_var.name)
+ index = self.loadvar(index_var.name)
+
+ targetty = self.typeof(target_var.name)
+ valuety = self.typeof(value_var.name)
+ indexty = self.typeof(index_var.name)
+
+ op = operator.setitem
+ fnop = self.context.typing_context.resolve_value_type(op)
+ callsig = fnop.get_call_type(
+ self.context.typing_context, signature.args, {},
+ )
+ impl = self.context.get_function(fnop, callsig)
+
+ # Convert argument to match
+ if isinstance(targetty, types.Optional):
+ target = self.context.cast(self.builder, target, targetty,
+ targetty.type)
+ else:
+ ul = types.unliteral
+ assert ul(targetty) == ul(signature.args[0])
+
+ index = self.context.cast(self.builder, index, indexty,
+ signature.args[1])
+ value = self.context.cast(self.builder, value, valuety,
+ signature.args[2])
+
+ return impl(self.builder, (target, index, value))
+
+ def lower_try_dynamic_raise(self, inst):
+ # Numba is a bit limited in what it can do with exceptions in a try
+ # block. Thus, it is safe to use the same code as the static try raise.
+ self.lower_static_try_raise(inst)
+
+ def lower_dynamic_raise(self, inst):
+ exc_args = inst.exc_args
+ args = []
+ nb_types = []
+ for exc_arg in exc_args:
+ if isinstance(exc_arg, ir.Var):
+ # dynamic values
+ typ = self.typeof(exc_arg.name)
+ val = self.loadvar(exc_arg.name)
+ self.incref(typ, val)
+ else:
+ typ = None
+ val = exc_arg
+ nb_types.append(typ)
+ args.append(val)
+
+ self.return_dynamic_exception(inst.exc_class, tuple(args),
+ tuple(nb_types), loc=self.loc)
+
+ def lower_static_raise(self, inst):
+ if inst.exc_class is None:
+ # Reraise
+ self.return_exception(None, loc=self.loc)
+ else:
+ self.return_exception(inst.exc_class, inst.exc_args, loc=self.loc)
+
+ def lower_static_try_raise(self, inst):
+ if inst.exc_class is None:
+ # Reraise
+ self.set_exception(None, loc=self.loc)
+ else:
+ self.set_exception(inst.exc_class, inst.exc_args, loc=self.loc)
+
+ def lower_assign(self, ty, inst):
+ value = inst.value
+ # In nopython mode, closure vars are frozen like globals
+ if isinstance(value, (ir.Const, ir.Global, ir.FreeVar)):
+ res = self.context.get_constant_generic(self.builder, ty,
+ value.value)
+ self.incref(ty, res)
+ return res
+
+ elif isinstance(value, ir.Expr):
+ return self.lower_expr(ty, value)
+
+ elif isinstance(value, ir.Var):
+ val = self.loadvar(value.name)
+ oty = self.typeof(value.name)
+ res = self.context.cast(self.builder, val, oty, ty)
+ self.incref(ty, res)
+ return res
+
+ elif isinstance(value, ir.Arg):
+ # Suspend debug info else all the arg repacking ends up being
+ # associated with some line or other and it's actually just a detail
+ # of Numba's CC.
+ with debuginfo.suspend_emission(self.builder):
+ # Cast from the argument type to the local variable type
+ # (note the "arg.FOO" convention as used in typeinfer)
+ argty = self.typeof("arg." + value.name)
+ if isinstance(argty, types.Omitted):
+ pyval = argty.value
+ tyctx = self.context.typing_context
+ valty = tyctx.resolve_value_type_prefer_literal(pyval)
+ # use the type of the constant value
+ const = self.context.get_constant_generic(
+ self.builder, valty, pyval,
+ )
+ # cast it to the variable type
+ res = self.context.cast(self.builder, const, valty, ty)
+ else:
+ val = self.fnargs[value.index]
+ res = self.context.cast(self.builder, val, argty, ty)
+ self.incref(ty, res)
+ return res
+
+ elif isinstance(value, ir.Yield):
+ res = self.lower_yield(ty, value)
+ self.incref(ty, res)
+ return res
+
+ raise NotImplementedError(type(value), value)
+
+ def lower_yield(self, retty, inst):
+ yp = self.generator_info.yield_points[inst.index]
+ assert yp.inst is inst
+ y = generators.LowerYield(self, yp, yp.live_vars)
+ y.lower_yield_suspend()
+ # Yield to caller
+ val = self.loadvar(inst.value.name)
+ typ = self.typeof(inst.value.name)
+ actual_rettyp = self.gentype.yield_type
+
+ # cast the local val to the type yielded
+ yret = self.context.cast(self.builder, val, typ, actual_rettyp)
+
+ # get the return repr of yielded value
+ retval = self.context.get_return_value(
+ self.builder, actual_rettyp, yret,
+ )
+
+ # return
+ self.call_conv.return_value(self.builder, retval)
+
+ # Resumption point
+ y.lower_yield_resume()
+ # None is returned by the yield expression
+ return self.context.get_constant_generic(self.builder, retty, None)
+
+ def lower_binop(self, resty, expr, op):
+ # if op in utils.OPERATORS_TO_BUILTINS:
+ # map operator.the_op => the corresponding types.Function()
+ # TODO: is this looks dodgy ...
+ op = self.context.typing_context.resolve_value_type(op)
+
+ lhs = expr.lhs
+ rhs = expr.rhs
+ static_lhs = expr.static_lhs
+ static_rhs = expr.static_rhs
+ lty = self.typeof(lhs.name)
+ rty = self.typeof(rhs.name)
+ lhs = self.loadvar(lhs.name)
+ rhs = self.loadvar(rhs.name)
+
+ # Convert argument to match
+ signature = self.fndesc.calltypes[expr]
+ lhs = self.context.cast(self.builder, lhs, lty, signature.args[0])
+ rhs = self.context.cast(self.builder, rhs, rty, signature.args[1])
+
+ def cast_result(res):
+ return self.context.cast(self.builder, res,
+ signature.return_type, resty)
+
+ # First try with static operands, if known
+ def try_static_impl(tys, args):
+ if any(a is ir.UNDEFINED for a in args):
+ return None
+ try:
+ if isinstance(op, types.Function):
+ static_sig = op.get_call_type(self.context.typing_context,
+ tys, {})
+ else:
+ static_sig = typing.signature(signature.return_type, *tys)
+ except TypingError:
+ return None
+ try:
+ static_impl = self.context.get_function(op, static_sig)
+ return static_impl(self.builder, args)
+ except NotImplementedError:
+ return None
+
+ res = try_static_impl(
+ (_lit_or_omitted(static_lhs), _lit_or_omitted(static_rhs)),
+ (static_lhs, static_rhs),
+ )
+ if res is not None:
+ return cast_result(res)
+
+ res = try_static_impl(
+ (_lit_or_omitted(static_lhs), rty),
+ (static_lhs, rhs),
+ )
+ if res is not None:
+ return cast_result(res)
+
+ res = try_static_impl(
+ (lty, _lit_or_omitted(static_rhs)),
+ (lhs, static_rhs),
+ )
+ if res is not None:
+ return cast_result(res)
+
+ # Normal implementation for generic arguments
+
+ sig = op.get_call_type(self.context.typing_context, signature.args, {})
+ impl = self.context.get_function(op, sig)
+ res = impl(self.builder, (lhs, rhs))
+ return cast_result(res)
+
+ def lower_getitem(self, resty, expr, value, index, signature):
+ baseval = self.loadvar(value.name)
+ indexval = self.loadvar(index.name)
+ # Get implementation of getitem
+ op = operator.getitem
+ fnop = self.context.typing_context.resolve_value_type(op)
+ callsig = fnop.get_call_type(
+ self.context.typing_context, signature.args, {},
+ )
+ impl = self.context.get_function(fnop, callsig)
+
+ argvals = (baseval, indexval)
+ argtyps = (self.typeof(value.name),
+ self.typeof(index.name))
+ castvals = [self.context.cast(self.builder, av, at, ft)
+ for av, at, ft in zip(argvals, argtyps,
+ signature.args)]
+ res = impl(self.builder, castvals)
+ return self.context.cast(self.builder, res,
+ signature.return_type,
+ resty)
+
+ def _cast_var(self, var, ty):
+ """
+ Cast a Numba IR variable to the given Numba type, returning a
+ low-level value.
+ """
+ if isinstance(var, _VarArgItem):
+ varty = self.typeof(var.vararg.name)[var.index]
+ val = self.builder.extract_value(self.loadvar(var.vararg.name),
+ var.index)
+ else:
+ varty = self.typeof(var.name)
+ val = self.loadvar(var.name)
+ return self.context.cast(self.builder, val, varty, ty)
+
+ def fold_call_args(self, fnty, signature, pos_args, vararg, kw_args):
+ if vararg:
+ # Inject *args from function call
+ # The lowering will be done in _cast_var() above.
+ tp_vararg = self.typeof(vararg.name)
+ assert isinstance(tp_vararg, types.BaseTuple)
+ pos_args = pos_args + [_VarArgItem(vararg, i)
+ for i in range(len(tp_vararg))]
+
+ # Fold keyword arguments and resolve default argument values
+ pysig = signature.pysig
+ if pysig is None:
+ if kw_args:
+ raise NotImplementedError("unsupported keyword arguments "
+ "when calling %s" % (fnty,))
+ argvals = [self._cast_var(var, sigty)
+ for var, sigty in zip(pos_args, signature.args)]
+ else:
+ def normal_handler(index, param, var):
+ return self._cast_var(var, signature.args[index])
+
+ def default_handler(index, param, default):
+ return self.context.get_constant_generic(
+ self.builder, signature.args[index], default)
+
+ def stararg_handler(index, param, vars):
+ stararg_ty = signature.args[index]
+ assert isinstance(stararg_ty, types.BaseTuple), stararg_ty
+ values = [self._cast_var(var, sigty)
+ for var, sigty in zip(vars, stararg_ty)]
+ return cgutils.make_anonymous_struct(self.builder, values)
+
+ argvals = typing.fold_arguments(pysig,
+ pos_args, dict(kw_args),
+ normal_handler,
+ default_handler,
+ stararg_handler)
+ return argvals
+
+ def lower_print(self, inst):
+ """
+ Lower a ir.Print()
+ """
+ # We handle this, as far as possible, as a normal call to built-in
+ # print(). This will make it easy to undo the special ir.Print
+ # rewrite when it becomes unnecessary (e.g. when we have native
+ # strings).
+ sig = self.fndesc.calltypes[inst]
+ assert sig.return_type == types.none
+ fnty = self.context.typing_context.resolve_value_type(print)
+
+ # Fix the call signature to inject any constant-inferred
+ # string argument
+ pos_tys = list(sig.args)
+ pos_args = list(inst.args)
+ for i in range(len(pos_args)):
+ if i in inst.consts:
+ pyval = inst.consts[i]
+ if isinstance(pyval, str):
+ pos_tys[i] = types.literal(pyval)
+
+ fixed_sig = typing.signature(sig.return_type, *pos_tys)
+ fixed_sig = fixed_sig.replace(pysig=sig.pysig)
+
+ argvals = self.fold_call_args(fnty, sig, pos_args, inst.vararg, {})
+ impl = self.context.get_function(print, fixed_sig)
+ impl(self.builder, argvals)
+
+ def lower_call(self, resty, expr):
+ signature = self.fndesc.calltypes[expr]
+ self.debug_print("# lower_call: expr = {0}".format(expr))
+ if isinstance(signature.return_type, types.Phantom):
+ return self.context.get_dummy_value()
+
+ fnty = self.typeof(expr.func.name)
+
+ if isinstance(fnty, types.ObjModeDispatcher):
+ res = self._lower_call_ObjModeDispatcher(fnty, expr, signature)
+
+ elif isinstance(fnty, types.ExternalFunction):
+ res = self._lower_call_ExternalFunction(fnty, expr, signature)
+
+ elif isinstance(fnty, types.ExternalFunctionPointer):
+ res = self._lower_call_ExternalFunctionPointer(
+ fnty, expr, signature)
+
+ elif isinstance(fnty, types.RecursiveCall):
+ res = self._lower_call_RecursiveCall(fnty, expr, signature)
+
+ elif isinstance(fnty, types.FunctionType):
+ res = self._lower_call_FunctionType(fnty, expr, signature)
+
+ else:
+ res = self._lower_call_normal(fnty, expr, signature)
+
+ # If lowering the call returned None, interpret that as returning dummy
+ # value if the return type of the function is void, otherwise there is
+ # a problem
+ if res is None:
+ if signature.return_type == types.void:
+ res = self.context.get_dummy_value()
+ else:
+ raise LoweringError(
+ msg="non-void function returns None from implementation",
+ loc=self.loc
+ )
+
+ return self.context.cast(self.builder, res, signature.return_type,
+ resty)
+
+ def _lower_call_ObjModeDispatcher(self, fnty, expr, signature):
+ from numba.core.pythonapi import ObjModeUtils
+
+ self.init_pyapi()
+ # Acquire the GIL
+ gil_state = self.pyapi.gil_ensure()
+ # Fix types
+ argnames = [a.name for a in expr.args]
+ argtypes = [self.typeof(a) for a in argnames]
+ argvalues = [self.loadvar(a) for a in argnames]
+ for v, ty in zip(argvalues, argtypes):
+ # Because .from_native_value steal the reference
+ self.incref(ty, v)
+
+ argobjs = [self.pyapi.from_native_value(atyp, aval,
+ self.env_manager)
+ for atyp, aval in zip(argtypes, argvalues)]
+
+ # Load objmode dispatcher
+ callee = ObjModeUtils(self.pyapi).load_dispatcher(fnty, argtypes)
+ # Make Call
+ ret_obj = self.pyapi.call_function_objargs(callee, argobjs)
+ has_exception = cgutils.is_null(self.builder, ret_obj)
+ with self. builder.if_else(has_exception) as (then, orelse):
+ # Handles exception
+ # This branch must exit the function
+ with then:
+ # Clean arg
+ for obj in argobjs:
+ self.pyapi.decref(obj)
+
+ # Release the GIL
+ self.pyapi.gil_release(gil_state)
+
+ # Return and signal exception
+ self.call_conv.return_exc(self.builder)
+
+ # Handles normal return
+ with orelse:
+ # Fix output value
+ native = self.pyapi.to_native_value(
+ fnty.dispatcher.output_types,
+ ret_obj,
+ )
+ output = native.value
+
+ # Release objs
+ self.pyapi.decref(ret_obj)
+ for obj in argobjs:
+ self.pyapi.decref(obj)
+
+ # cleanup output
+ if callable(native.cleanup):
+ native.cleanup()
+
+ # Release the GIL
+ self.pyapi.gil_release(gil_state)
+
+ # Error during unboxing
+ with self.builder.if_then(native.is_error):
+ self.call_conv.return_exc(self.builder)
+
+ return output
+
+ def _lower_call_ExternalFunction(self, fnty, expr, signature):
+ # Handle a named external function
+ self.debug_print("# external function")
+ argvals = self.fold_call_args(
+ fnty, signature, expr.args, expr.vararg, expr.kws,
+ )
+ fndesc = funcdesc.ExternalFunctionDescriptor(
+ fnty.symbol, fnty.sig.return_type, fnty.sig.args)
+ func = self.context.declare_external_function(
+ self.builder.module, fndesc)
+ return self.context.call_external_function(
+ self.builder, func, fndesc.argtypes, argvals,
+ )
+
+ def _lower_call_ExternalFunctionPointer(self, fnty, expr, signature):
+ # Handle a C function pointer
+ self.debug_print("# calling external function pointer")
+ argvals = self.fold_call_args(
+ fnty, signature, expr.args, expr.vararg, expr.kws,
+ )
+ pointer = self.loadvar(expr.func.name)
+ # If the external function pointer uses libpython
+ if fnty.requires_gil:
+ self.init_pyapi()
+ # Acquire the GIL
+ gil_state = self.pyapi.gil_ensure()
+ # Make PyObjects
+ newargvals = []
+ pyvals = []
+ for exptyp, gottyp, aval in zip(fnty.sig.args, signature.args,
+ argvals):
+ # Adjust argument values to pyobjects
+ if exptyp == types.ffi_forced_object:
+ self.incref(gottyp, aval)
+ obj = self.pyapi.from_native_value(
+ gottyp, aval, self.env_manager,
+ )
+ newargvals.append(obj)
+ pyvals.append(obj)
+ else:
+ newargvals.append(aval)
+
+ # Call external function
+ res = self.context.call_function_pointer(
+ self.builder, pointer, newargvals, fnty.cconv,
+ )
+ # Release PyObjects
+ for obj in pyvals:
+ self.pyapi.decref(obj)
+
+ # Release the GIL
+ self.pyapi.gil_release(gil_state)
+ # If the external function pointer does NOT use libpython
+ else:
+ res = self.context.call_function_pointer(
+ self.builder, pointer, argvals, fnty.cconv,
+ )
+ return res
+
+ def _lower_call_RecursiveCall(self, fnty, expr, signature):
+ # Recursive call
+ argvals = self.fold_call_args(
+ fnty, signature, expr.args, expr.vararg, expr.kws,
+ )
+ rec_ov = fnty.get_overloads(signature.args)
+ mangler = self.context.mangler or default_mangler
+ abi_tags = self.fndesc.abi_tags
+ mangled_name = mangler(rec_ov.qualname, signature.args,
+ abi_tags=abi_tags, uid=rec_ov.uid)
+ # special case self recursion
+ if self.builder.function.name.startswith(mangled_name):
+ res = self.context.call_internal(
+ self.builder, self.fndesc, signature, argvals,
+ )
+ else:
+ res = self.context.call_unresolved(
+ self.builder, mangled_name, signature, argvals,
+ )
+ return res
+
+ def _lower_call_FunctionType(self, fnty, expr, signature):
+ self.debug_print("# calling first-class function type")
+ sig = types.unliteral(signature)
+ if not fnty.check_signature(signature):
+ # value dependent polymorphism?
+ raise UnsupportedError(
+ f'mismatch of function types:'
+ f' expected {fnty} but got {types.FunctionType(sig)}')
+ argvals = self.fold_call_args(
+ fnty, sig, expr.args, expr.vararg, expr.kws,
+ )
+ return self.__call_first_class_function_pointer(
+ fnty.ftype, expr.func.name, sig, argvals,
+ )
+
+ def __call_first_class_function_pointer(self, ftype, fname, sig, argvals):
+ """
+ Calls a first-class function pointer.
+
+ This function is responsible for calling a first-class function pointer,
+ which can either be a JIT-compiled function or a Python function. It
+ determines if a JIT address is available, and if so, calls the function
+ using the JIT address. Otherwise, it calls the function using a function
+ pointer obtained from the `__get_first_class_function_pointer` method.
+
+ Args:
+ ftype: The type of the function.
+ fname: The name of the function.
+ sig: The signature of the function.
+ argvals: The argument values to pass to the function.
+
+ Returns:
+ The result of calling the function.
+ """
+ context = self.context
+ builder = self.builder
+ # Determine if jit address is available
+ fstruct = self.loadvar(fname)
+ struct = cgutils.create_struct_proxy(self.typeof(fname))(
+ context, builder, value=fstruct
+ )
+ jit_addr = struct.jit_addr
+ jit_addr.name = f'jit_addr_of_{fname}'
+
+ ctx = context
+ res_slot = cgutils.alloca_once(builder,
+ ctx.get_value_type(sig.return_type))
+
+ if_jit_addr_is_null = builder.if_else(
+ cgutils.is_null(builder, jit_addr),
+ likely=False
+ )
+ with if_jit_addr_is_null as (then, orelse):
+ with then:
+ func_ptr = self.__get_first_class_function_pointer(
+ ftype, fname, sig)
+ res = builder.call(func_ptr, argvals)
+ builder.store(res, res_slot)
+
+ with orelse:
+ llty = ctx.call_conv.get_function_type(
+ sig.return_type,
+ sig.args
+ ).as_pointer()
+ func_ptr = builder.bitcast(jit_addr, llty)
+ # call
+ status, res = ctx.call_conv.call_function(
+ builder, func_ptr, sig.return_type, sig.args, argvals
+ )
+ with cgutils.if_unlikely(builder, status.is_error):
+ context.call_conv.return_status_propagate(builder, status)
+ builder.store(res, res_slot)
+ return builder.load(res_slot)
+
+ def __get_first_class_function_pointer(self, ftype, fname, sig):
+ from numba.experimental.function_type import lower_get_wrapper_address
+
+ llty = self.context.get_value_type(ftype)
+ fstruct = self.loadvar(fname)
+ addr = self.builder.extract_value(fstruct, 0,
+ name='addr_of_%s' % (fname))
+
+ fptr = cgutils.alloca_once(self.builder, llty,
+ name="fptr_of_%s" % (fname))
+ with self.builder.if_else(
+ cgutils.is_null(self.builder, addr),
+ likely=False) as (then, orelse):
+ with then:
+ self.init_pyapi()
+ # Acquire the GIL
+ gil_state = self.pyapi.gil_ensure()
+ pyaddr = self.builder.extract_value(
+ fstruct, 1,
+ name='pyaddr_of_%s' % (fname))
+ # try to recover the function address, see
+ # test_zero_address BadToGood example in
+ # test_function_type.py
+ addr1 = lower_get_wrapper_address(
+ self.context, self.builder, pyaddr, sig,
+ failure_mode='ignore')
+ with self.builder.if_then(
+ cgutils.is_null(self.builder, addr1), likely=False):
+ self.return_exception(
+ RuntimeError,
+ exc_args=(f"{ftype} function address is null",),
+ loc=self.loc)
+ addr2 = self.pyapi.long_as_voidptr(addr1)
+ self.builder.store(self.builder.bitcast(addr2, llty), fptr)
+ self.pyapi.decref(addr1)
+ self.pyapi.gil_release(gil_state)
+ with orelse:
+ self.builder.store(self.builder.bitcast(addr, llty), fptr)
+ return self.builder.load(fptr)
+
+ def _lower_call_normal(self, fnty, expr, signature):
+ # Normal function resolution
+ self.debug_print("# calling normal function: {0}".format(fnty))
+ self.debug_print("# signature: {0}".format(signature))
+ if isinstance(fnty, types.ObjModeDispatcher):
+ argvals = expr.func.args
+ else:
+ argvals = self.fold_call_args(
+ fnty, signature, expr.args, expr.vararg, expr.kws,
+ )
+ tname = expr.target
+ if tname is not None:
+ from numba.core.target_extension import resolve_dispatcher_from_str
+ disp = resolve_dispatcher_from_str(tname)
+ hw_ctx = disp.targetdescr.target_context
+ impl = hw_ctx.get_function(fnty, signature)
+ else:
+ impl = self.context.get_function(fnty, signature)
+ if signature.recvr:
+ # The "self" object is passed as the function object
+ # for bounded function
+ the_self = self.loadvar(expr.func.name)
+ # Prepend the self reference
+ argvals = [the_self] + list(argvals)
+
+ res = impl(self.builder, argvals, self.loc)
+ return res
+
+ def lower_expr(self, resty, expr):
+ if expr.op == 'binop':
+ return self.lower_binop(resty, expr, expr.fn)
+ elif expr.op == 'inplace_binop':
+ lty = self.typeof(expr.lhs.name)
+ if lty.mutable:
+ return self.lower_binop(resty, expr, expr.fn)
+ else:
+ # inplace operators on non-mutable types reuse the same
+ # definition as the corresponding copying operators.)
+ return self.lower_binop(resty, expr, expr.immutable_fn)
+ elif expr.op == 'unary':
+ val = self.loadvar(expr.value.name)
+ typ = self.typeof(expr.value.name)
+ func_ty = self.context.typing_context.resolve_value_type(expr.fn)
+ # Get function
+ signature = self.fndesc.calltypes[expr]
+ impl = self.context.get_function(func_ty, signature)
+ # Convert argument to match
+ val = self.context.cast(self.builder, val, typ, signature.args[0])
+ res = impl(self.builder, [val])
+ res = self.context.cast(self.builder, res,
+ signature.return_type, resty)
+ return res
+
+ elif expr.op == 'call':
+ res = self.lower_call(resty, expr)
+ return res
+
+ elif expr.op == 'pair_first':
+ val = self.loadvar(expr.value.name)
+ ty = self.typeof(expr.value.name)
+ res = self.context.pair_first(self.builder, val, ty)
+ self.incref(resty, res)
+ return res
+
+ elif expr.op == 'pair_second':
+ val = self.loadvar(expr.value.name)
+ ty = self.typeof(expr.value.name)
+ res = self.context.pair_second(self.builder, val, ty)
+ self.incref(resty, res)
+ return res
+
+ elif expr.op in ('getiter', 'iternext'):
+ val = self.loadvar(expr.value.name)
+ ty = self.typeof(expr.value.name)
+ signature = self.fndesc.calltypes[expr]
+ impl = self.context.get_function(expr.op, signature)
+ [fty] = signature.args
+ castval = self.context.cast(self.builder, val, ty, fty)
+ res = impl(self.builder, (castval,))
+ res = self.context.cast(self.builder, res, signature.return_type,
+ resty)
+ return res
+
+ elif expr.op == 'exhaust_iter':
+ val = self.loadvar(expr.value.name)
+ ty = self.typeof(expr.value.name)
+ # Unpack optional
+ if isinstance(ty, types.Optional):
+ val = self.context.cast(self.builder, val, ty, ty.type)
+ ty = ty.type
+
+ # If we have a tuple, we needn't do anything
+ # (and we can't iterate over the heterogeneous ones).
+ if isinstance(ty, types.BaseTuple):
+ assert ty == resty
+ self.incref(ty, val)
+ return val
+
+ itemty = ty.iterator_type.yield_type
+ tup = self.context.get_constant_undef(resty)
+ pairty = types.Pair(itemty, types.boolean)
+ getiter_sig = typing.signature(ty.iterator_type, ty)
+ getiter_impl = self.context.get_function('getiter',
+ getiter_sig)
+ iternext_sig = typing.signature(pairty, ty.iterator_type)
+ iternext_impl = self.context.get_function('iternext',
+ iternext_sig)
+ iterobj = getiter_impl(self.builder, (val,))
+ # We call iternext() as many times as desired (`expr.count`).
+ for i in range(expr.count):
+ pair = iternext_impl(self.builder, (iterobj,))
+ is_valid = self.context.pair_second(self.builder,
+ pair, pairty)
+ with cgutils.if_unlikely(self.builder,
+ self.builder.not_(is_valid)):
+ self.return_exception(ValueError, loc=self.loc)
+ item = self.context.pair_first(self.builder,
+ pair, pairty)
+ tup = self.builder.insert_value(tup, item, i)
+
+ # Call iternext() once more to check that the iterator
+ # is exhausted.
+ pair = iternext_impl(self.builder, (iterobj,))
+ is_valid = self.context.pair_second(self.builder,
+ pair, pairty)
+ with cgutils.if_unlikely(self.builder, is_valid):
+ self.return_exception(ValueError, loc=self.loc)
+
+ self.decref(ty.iterator_type, iterobj)
+ return tup
+
+ elif expr.op == "getattr":
+ val = self.loadvar(expr.value.name)
+ ty = self.typeof(expr.value.name)
+
+ if isinstance(resty, types.BoundFunction):
+ # if we are getting out a method, assume we have typed this
+ # properly and just build a bound function object
+ casted = self.context.cast(self.builder, val, ty, resty.this)
+ res = self.context.get_bound_function(self.builder, casted,
+ resty.this)
+ self.incref(resty, res)
+ return res
+ else:
+ impl = self.context.get_getattr(ty, expr.attr)
+ attrty = self.context.typing_context.resolve_getattr(ty,
+ expr.attr)
+
+ if impl is None:
+ # ignore the attribute
+ return self.context.get_dummy_value()
+ else:
+ res = impl(self.context, self.builder, ty, val, expr.attr)
+
+ # Cast the attribute type to the expected output type
+ res = self.context.cast(self.builder, res, attrty, resty)
+ return res
+
+ elif expr.op == "static_getitem":
+ signature = typing.signature(
+ resty,
+ self.typeof(expr.value.name),
+ _lit_or_omitted(expr.index),
+ )
+ try:
+ # Both get_function() and the returned implementation can
+ # raise NotImplementedError if the types aren't supported
+ impl = self.context.get_function("static_getitem", signature)
+ return impl(self.builder,
+ (self.loadvar(expr.value.name), expr.index))
+ except NotImplementedError:
+ if expr.index_var is None:
+ raise
+ # Fall back on the generic getitem() implementation
+ # for this type.
+ signature = self.fndesc.calltypes[expr]
+ return self.lower_getitem(resty, expr, expr.value,
+ expr.index_var, signature)
+ elif expr.op == "typed_getitem":
+ signature = typing.signature(
+ resty,
+ self.typeof(expr.value.name),
+ self.typeof(expr.index.name),
+ )
+ impl = self.context.get_function("typed_getitem", signature)
+ return impl(self.builder, (self.loadvar(expr.value.name),
+ self.loadvar(expr.index.name)))
+ elif expr.op == "getitem":
+ signature = self.fndesc.calltypes[expr]
+ return self.lower_getitem(resty, expr, expr.value, expr.index,
+ signature)
+
+ elif expr.op == "build_tuple":
+ itemvals = [self.loadvar(i.name) for i in expr.items]
+ itemtys = [self.typeof(i.name) for i in expr.items]
+ castvals = [self.context.cast(self.builder, val, fromty, toty)
+ for val, toty, fromty in zip(itemvals, resty, itemtys)]
+ tup = self.context.make_tuple(self.builder, resty, castvals)
+ self.incref(resty, tup)
+ return tup
+
+ elif expr.op == "build_list":
+ itemvals = [self.loadvar(i.name) for i in expr.items]
+ itemtys = [self.typeof(i.name) for i in expr.items]
+ if isinstance(resty, types.LiteralList):
+ castvals = [self.context.cast(self.builder, val, fromty, toty)
+ for val, toty, fromty in zip(itemvals, resty.types,
+ itemtys)]
+ tup = self.context.make_tuple(self.builder,
+ types.Tuple(resty.types),
+ castvals)
+ self.incref(resty, tup)
+ return tup
+ else:
+ castvals = [self.context.cast(self.builder, val, fromty,
+ resty.dtype)
+ for val, fromty in zip(itemvals, itemtys)]
+ return self.context.build_list(self.builder, resty, castvals)
+
+ elif expr.op == "build_set":
+ # Insert in reverse order, as Python does
+ items = expr.items[::-1]
+ itemvals = [self.loadvar(i.name) for i in items]
+ itemtys = [self.typeof(i.name) for i in items]
+ castvals = [self.context.cast(self.builder, val, fromty,
+ resty.dtype)
+ for val, fromty in zip(itemvals, itemtys)]
+ return self.context.build_set(self.builder, resty, castvals)
+
+ elif expr.op == "build_map":
+ items = expr.items
+ keys, values = [], []
+ key_types, value_types = [], []
+ for k, v in items:
+ key = self.loadvar(k.name)
+ keytype = self.typeof(k.name)
+ val = self.loadvar(v.name)
+ valtype = self.typeof(v.name)
+ keys.append(key)
+ values.append(val)
+ key_types.append(keytype)
+ value_types.append(valtype)
+ return self.context.build_map(self.builder, resty,
+ list(zip(key_types, value_types)),
+ list(zip(keys, values)))
+
+ elif expr.op == "cast":
+ val = self.loadvar(expr.value.name)
+ ty = self.typeof(expr.value.name)
+ castval = self.context.cast(self.builder, val, ty, resty)
+ self.incref(resty, castval)
+ return castval
+
+ elif expr.op == "phi":
+ raise LoweringError("PHI not stripped")
+
+ elif expr.op == 'null':
+ return self.context.get_constant_null(resty)
+
+ elif expr.op == 'undef':
+ # Numba does not raise an UnboundLocalError for undefined variables.
+ # The variable is set to zero.
+ return self.context.get_constant_null(resty)
+
+ elif expr.op in self.context.special_ops:
+ res = self.context.special_ops[expr.op](self, expr)
+ return res
+
+ raise NotImplementedError(expr)
+
+ def _alloca_var(self, name, fetype):
+ """
+ Ensure the given variable has an allocated stack slot (if needed).
+ """
+ if name in self.varmap:
+ # quit early
+ return
+
+ # If the name is used in multiple blocks or lowering with debuginfo...
+ if ((name not in self._singly_assigned_vars) or
+ self._disable_sroa_like_opt):
+ # If not already defined, allocate it
+ ptr = self.alloca(name, fetype)
+ # Remember the pointer
+ self.varmap[name] = ptr
+
+ def getvar(self, name):
+ """
+ Get a pointer to the given variable's slot.
+ """
+ if not self._disable_sroa_like_opt:
+ assert name not in self._blk_local_varmap
+ assert name not in self._singly_assigned_vars
+ if name not in self.varmap:
+ # Allocate undefined variable as needed.
+ # NOTE: Py3.12 use of LOAD_FAST_AND_CLEAR will allow variable be
+ # referenced before it is defined.
+ self._alloca_var(name, self.typeof(name))
+ return self.varmap[name]
+
+ def loadvar(self, name):
+ """
+ Load the given variable's value.
+ """
+ if name in self._blk_local_varmap and not self._disable_sroa_like_opt:
+ return self._blk_local_varmap[name]
+ ptr = self.getvar(name)
+
+ # Don't associate debuginfo with the load for a function arg else it
+ # creates instructions ahead of the first source line of the
+ # function which then causes problems with breaking on the function
+ # symbol (it hits the symbol, not the first line).
+ if name in self.func_ir.arg_names:
+ with debuginfo.suspend_emission(self.builder):
+ return self.builder.load(ptr)
+ else:
+ return self.builder.load(ptr)
+
+ def storevar(self, value, name, argidx=None):
+ """
+ Store the value into the given variable.
+ """
+ fetype = self.typeof(name)
+ # Define if not already
+ self._alloca_var(name, fetype)
+
+ # Store variable
+ if (name in self._singly_assigned_vars and
+ not self._disable_sroa_like_opt):
+ self._blk_local_varmap[name] = value
+ else:
+ if argidx is None:
+ # Clean up existing value stored in the variable, not needed
+ # if it's an arg
+ old = self.loadvar(name)
+ self.decref(fetype, old)
+
+ # stack stored variable
+ ptr = self.getvar(name)
+ if value.type != ptr.type.pointee:
+ msg = ("Storing {value.type} to ptr of {ptr.type.pointee} "
+ "('{name}'). FE type {fetype}").format(value=value,
+ ptr=ptr,
+ fetype=fetype,
+ name=name)
+ raise AssertionError(msg)
+
+ # If this store is associated with an argument to the function (i.e.
+ # store following reassemble from CC splatting structs as many args
+ # to the function) then mark this variable as such.
+ if argidx is not None:
+ with debuginfo.suspend_emission(self.builder):
+ self.builder.store(value, ptr)
+ loc = self.defn_loc # the line with `def `
+ lltype = self.context.get_value_type(fetype)
+ sizeof = self.context.get_abi_sizeof(lltype)
+ datamodel = self.context.data_model_manager[fetype]
+ self.debuginfo.mark_variable(self.builder, ptr, name=name,
+ lltype=lltype, size=sizeof,
+ line=loc.line, datamodel=datamodel,
+ argidx=argidx)
+ else:
+ self.builder.store(value, ptr)
+
+ def delvar(self, name):
+ """
+ Delete the given variable.
+ """
+ fetype = self.typeof(name)
+
+ # Out-of-order
+ if (name not in self._blk_local_varmap and
+ not self._disable_sroa_like_opt):
+ if name in self._singly_assigned_vars:
+ self._singly_assigned_vars.discard(name)
+
+ # Define if not already (may happen if the variable is deleted
+ # at the beginning of a loop, but only set later in the loop)
+ self._alloca_var(name, fetype)
+
+ if name in self._blk_local_varmap and not self._disable_sroa_like_opt:
+ llval = self._blk_local_varmap[name]
+ self.decref(fetype, llval)
+ else:
+ ptr = self.getvar(name)
+ self.decref(fetype, self.builder.load(ptr))
+ # Zero-fill variable to avoid double frees on subsequent dels
+ self.builder.store(Constant(ptr.type.pointee, None), ptr)
+
+ def alloca(self, name, type):
+ lltype = self.context.get_value_type(type)
+ datamodel = self.context.data_model_manager[type]
+ return self.alloca_lltype(name, lltype, datamodel=datamodel)
+
+ def alloca_lltype(self, name, lltype, datamodel=None):
+ # Is user variable?
+ is_uservar = not name.startswith('$')
+ # Allocate space for variable
+ aptr = cgutils.alloca_once(self.builder, lltype,
+ name=name, zfill=False)
+
+ # Emit debug info for user variable
+ if is_uservar:
+ # Don't associate debuginfo with the alloca for a function arg, this
+ # is handled by the first store to the alloca so that repacking the
+ # splatted args from the CC is dealt with.
+ if name not in self.func_ir.arg_names:
+ sizeof = self.context.get_abi_sizeof(lltype)
+ self.debuginfo.mark_variable(self.builder, aptr, name=name,
+ lltype=lltype, size=sizeof,
+ line=self.loc.line,
+ datamodel=datamodel,)
+ return aptr
+
+ def incref(self, typ, val):
+ if not self.context.enable_nrt:
+ return
+
+ self.context.nrt.incref(self.builder, typ, val)
+
+ def decref(self, typ, val):
+ if not self.context.enable_nrt:
+ return
+
+ # do not associate decref with "use", it creates "jumpy" line info as
+ # the decrefs are usually where the ir.Del nodes are, which is at the
+ # end of the block.
+ with debuginfo.suspend_emission(self.builder):
+ self.context.nrt.decref(self.builder, typ, val)
+
+
+def _lit_or_omitted(value):
+ """Returns a Literal instance if the type of value is supported;
+ otherwise, return `Omitted(value)`.
+ """
+ try:
+ return types.literal(value)
+ except LiteralTypingError:
+ return types.Omitted(value)
diff --git a/venv/lib/python3.10/site-packages/numba/core/new_boxing.py b/venv/lib/python3.10/site-packages/numba/core/new_boxing.py
new file mode 100644
index 0000000000000000000000000000000000000000..83955504bf9ada44067c099bfaf5ffec80a5300d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/new_boxing.py
@@ -0,0 +1,1362 @@
+"""
+Boxing and unboxing of native Numba values to / from CPython objects.
+"""
+
+from llvmlite import ir
+
+from numba.core import types, cgutils
+from numba.core.pythonapi import box, unbox, reflect, NativeValue
+from numba.core.errors import NumbaNotImplementedError, TypingError
+from numba.core.typing.typeof import typeof, Purpose
+
+from numba.cpython import setobj, listobj
+from numba.np import numpy_support
+from contextlib import contextmanager, ExitStack
+
+
+#
+# Scalar types
+#
+
+def box_np_scalars(typ, val, c, py_boxing_func, py_type):
+ py_scalar = py_boxing_func(py_type, val, c)
+ np_scalar = cgutils.alloca_once_value(c.builder, c.pyapi.borrow_none())
+ with cgutils.if_likely(c.builder, cgutils.is_not_null(c.builder, py_scalar)):
+ numpy_name = c.context.insert_const_string(c.builder.module, 'numpy')
+ numpy_module = c.pyapi.import_module(numpy_name)
+ with cgutils.if_likely(c.builder, cgutils.is_not_null(c.builder, numpy_module)):
+ type_str = typ.name.split('np_')[1]
+ np_scalar_constructor = c.pyapi.object_getattr_string(numpy_module, type_str)
+ c.pyapi.decref(numpy_module)
+ with cgutils.if_likely(c.builder, cgutils.is_not_null(c.builder, np_scalar_constructor)):
+ c.builder.store(c.pyapi.call_function_objargs(np_scalar_constructor, (py_scalar,)), np_scalar)
+ c.pyapi.decref(np_scalar_constructor)
+ c.pyapi.decref(py_scalar)
+ return c.builder.load(np_scalar)
+
+
+@box(types.PythonBoolean)
+def box_py_bool(typ, val, c):
+ return c.pyapi.bool_from_bool(val)
+
+
+@box(types.NumPyBoolean)
+def box_np_bool(typ, val, c):
+ return box_np_scalars(typ, val, c, box_py_bool, types.py_bool)
+
+
+@unbox(types.PythonBoolean)
+@unbox(types.NumPyBoolean)
+def unbox_boolean(typ, obj, c):
+ istrue = c.pyapi.object_istrue(obj)
+ zero = ir.Constant(istrue.type, 0)
+ val = c.builder.icmp_signed('!=', istrue, zero)
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.PythonIntegerLiteral)
+@box(types.PythonBooleanLiteral)
+@box(types.NumPyIntegerLiteral)
+@box(types.NumPyBooleanLiteral)
+def box_literal_integer(typ, val, c):
+ val = c.context.cast(c.builder, val, typ, typ.literal_type)
+ return c.box(typ.literal_type, val)
+
+
+@unbox(types.PythonInteger)
+@unbox(types.NumPyInteger)
+def unbox_integer(typ, obj, c):
+ ll_type = c.context.get_argument_type(typ)
+ val = cgutils.alloca_once(c.builder, ll_type)
+ longobj = c.pyapi.number_long(obj)
+ with c.pyapi.if_object_ok(longobj):
+ if typ.signed:
+ llval = c.pyapi.long_as_longlong(longobj)
+ else:
+ llval = c.pyapi.long_as_ulonglong(longobj)
+ c.pyapi.decref(longobj)
+ c.builder.store(c.builder.trunc(llval, ll_type), val)
+ return NativeValue(c.builder.load(val),
+ is_error=c.pyapi.c_api_error())
+
+
+@box(types.PythonInteger)
+def box_py_integer(typ, val, c):
+ ival = c.builder.sext(val, c.pyapi.longlong)
+ return c.pyapi.long_from_longlong(ival)
+
+
+@box(types.NumPyInteger)
+def box_np_integer(typ, val, c):
+ return box_np_scalars(typ, val, c, box_py_integer, types.py_int)
+
+
+@box(types.PythonFloat)
+def box_py_float(typ, val, c):
+ return c.pyapi.float_from_double(val)
+
+
+@box(types.NumPyFloat)
+def box_np_float(typ, val, c):
+ if typ.bitwidth <= 32:
+ val = c.builder.fpext(val, c.pyapi.double)
+ return box_np_scalars(typ, val, c, box_py_float, types.py_float)
+
+
+@unbox(types.PythonFloat)
+@unbox(types.NumPyFloat)
+def unbox_float(typ, obj, c):
+ fobj = c.pyapi.number_float(obj)
+ dbval = c.pyapi.float_as_double(fobj)
+ c.pyapi.decref(fobj)
+ if typ.bitwidth <= 32:
+ val = c.builder.fptrunc(dbval,
+ c.context.get_argument_type(typ))
+ else:
+ val = dbval
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.PythonComplex)
+def box_py_complex(typ, val, c):
+ cval = c.context.make_complex(c.builder, typ, value=val)
+ assert typ == types.py_complex
+ freal, fimag = cval.real, cval.imag
+ return c.pyapi.complex_from_doubles(freal, fimag)
+
+
+@unbox(types.PythonComplex)
+@unbox(types.NumPyComplex)
+def unbox_py_complex(typ, obj, c):
+ c128 = c.context.make_complex(c.builder, types.py_complex)
+ ok = c.pyapi.complex_adaptor(obj, c128._getpointer())
+ failed = cgutils.is_false(c.builder, ok)
+
+ with cgutils.if_unlikely(c.builder, failed):
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "conversion to %s failed" % (typ,))
+
+ if typ == types.np_complex64:
+ # Downcast to complex64 if necessary
+ cplx = c.context.make_complex(c.builder, typ)
+ cplx.real = c.context.cast(c.builder, c128.real,
+ types.py_float, types.np_float32)
+ cplx.imag = c.context.cast(c.builder, c128.imag,
+ types.py_float, types.np_float32)
+ else:
+ cplx = c128
+
+ return NativeValue(cplx._getvalue(), is_error=failed)
+
+
+@box(types.NumPyComplex)
+def box_np_complex(typ, val, c):
+ cval = c.context.make_complex(c.builder, typ, value=val)
+ if typ == types.np_complex64:
+ freal = c.builder.fpext(cval.real, c.pyapi.double)
+ fimag = c.builder.fpext(cval.imag, c.pyapi.double)
+ else:
+ assert typ == types.np_complex128
+ freal, fimag = cval.real, cval.imag
+ py_scalar = c.pyapi.complex_from_doubles(freal, fimag)
+ np_scalar = cgutils.alloca_once_value(c.builder, c.pyapi.borrow_none())
+ with cgutils.if_likely(c.builder, cgutils.is_not_null(c.builder, py_scalar)):
+ numpy_name = c.context.insert_const_string(c.builder.module, 'numpy')
+ numpy_module = c.pyapi.import_module(numpy_name)
+ type_str = typ.name.split('np_')[1]
+ np_scalar_constructor = c.pyapi.object_getattr_string(numpy_module, type_str)
+ with cgutils.if_likely(c.builder, cgutils.is_not_null(c.builder, np_scalar_constructor)):
+ c.builder.store(c.pyapi.call_function_objargs(np_scalar_constructor, (py_scalar,)), np_scalar)
+ c.pyapi.decref(np_scalar_constructor)
+ c.pyapi.decref(py_scalar)
+ return c.builder.load(np_scalar)
+
+
+@box(types.NoneType)
+def box_none(typ, val, c):
+ return c.pyapi.make_none()
+
+@unbox(types.NoneType)
+@unbox(types.EllipsisType)
+def unbox_none(typ, val, c):
+ return NativeValue(c.context.get_dummy_value())
+
+
+@box(types.NPDatetime)
+def box_npdatetime(typ, val, c):
+ return c.pyapi.create_np_datetime(val, typ.unit_code)
+
+@unbox(types.NPDatetime)
+def unbox_npdatetime(typ, obj, c):
+ val = c.pyapi.extract_np_datetime(obj)
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.NPTimedelta)
+def box_nptimedelta(typ, val, c):
+ return c.pyapi.create_np_timedelta(val, typ.unit_code)
+
+@unbox(types.NPTimedelta)
+def unbox_nptimedelta(typ, obj, c):
+ val = c.pyapi.extract_np_timedelta(obj)
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.RawPointer)
+def box_raw_pointer(typ, val, c):
+ """
+ Convert a raw pointer to a Python int.
+ """
+ ll_intp = c.context.get_value_type(types.uintp)
+ addr = c.builder.ptrtoint(val, ll_intp)
+ return c.box(types.uintp, addr)
+
+
+@box(types.EnumMember)
+def box_enum(typ, val, c):
+ """
+ Fetch an enum member given its native value.
+ """
+ valobj = c.box(typ.dtype, val)
+ # Call the enum class with the value object
+ cls_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ.instance_class))
+ return c.pyapi.call_function_objargs(cls_obj, (valobj,))
+
+
+@unbox(types.EnumMember)
+def unbox_enum(typ, obj, c):
+ """
+ Convert an enum member's value to its native value.
+ """
+ valobj = c.pyapi.object_getattr_string(obj, "value")
+ return c.unbox(typ.dtype, valobj)
+
+
+@box(types.UndefVar)
+def box_undefvar(typ, val, c):
+ """This type cannot be boxed, there's no Python equivalent"""
+ msg = ("UndefVar type cannot be boxed, there is no Python equivalent of "
+ "this type.")
+ raise TypingError(msg)
+
+#
+# Composite types
+#
+
+@box(types.Record)
+def box_record(typ, val, c):
+ # Note we will create a copy of the record
+ # This is the only safe way.
+ size = ir.Constant(ir.IntType(32), val.type.pointee.count)
+ ptr = c.builder.bitcast(val, ir.PointerType(ir.IntType(8)))
+ return c.pyapi.recreate_record(ptr, size, typ.dtype, c.env_manager)
+
+
+@unbox(types.Record)
+def unbox_record(typ, obj, c):
+ buf = c.pyapi.alloca_buffer()
+ ptr = c.pyapi.extract_record_data(obj, buf)
+ is_error = cgutils.is_null(c.builder, ptr)
+
+ ltyp = c.context.get_value_type(typ)
+ val = c.builder.bitcast(ptr, ltyp)
+
+ def cleanup():
+ c.pyapi.release_buffer(buf)
+ return NativeValue(val, cleanup=cleanup, is_error=is_error)
+
+
+@box(types.UnicodeCharSeq)
+def box_unicodecharseq(typ, val, c):
+ # XXX could kind be determined from strptr?
+ unicode_kind = {
+ 1: c.pyapi.py_unicode_1byte_kind,
+ 2: c.pyapi.py_unicode_2byte_kind,
+ 4: c.pyapi.py_unicode_4byte_kind}[numpy_support.sizeof_unicode_char]
+ kind = c.context.get_constant(types.int32, unicode_kind)
+ rawptr = cgutils.alloca_once_value(c.builder, value=val)
+ strptr = c.builder.bitcast(rawptr, c.pyapi.cstring)
+
+ fullsize = c.context.get_constant(types.intp, typ.count)
+ zero = fullsize.type(0)
+ one = fullsize.type(1)
+ step = fullsize.type(numpy_support.sizeof_unicode_char)
+ count = cgutils.alloca_once_value(c.builder, zero)
+ with cgutils.loop_nest(c.builder, [fullsize], fullsize.type) as [idx]:
+ # Get char at idx
+ ch = c.builder.load(c.builder.gep(strptr, [c.builder.mul(idx, step)]))
+ # If the char is a non-null-byte, store the next index as count
+ with c.builder.if_then(cgutils.is_not_null(c.builder, ch)):
+ c.builder.store(c.builder.add(idx, one), count)
+ strlen = c.builder.load(count)
+ return c.pyapi.string_from_kind_and_data(kind, strptr, strlen)
+
+
+@unbox(types.UnicodeCharSeq)
+def unbox_unicodecharseq(typ, obj, c):
+ lty = c.context.get_value_type(typ)
+
+ ok, buffer, size, kind, is_ascii, hashv = \
+ c.pyapi.string_as_string_size_and_kind(obj)
+
+ # If conversion is ok, copy the buffer to the output storage.
+ with cgutils.if_likely(c.builder, ok):
+ # Check if the returned string size fits in the charseq
+ storage_size = ir.Constant(size.type, typ.count)
+ size_fits = c.builder.icmp_unsigned("<=", size, storage_size)
+
+ # Allow truncation of string
+ size = c.builder.select(size_fits, size, storage_size)
+
+ # Initialize output to zero bytes
+ null_string = ir.Constant(lty, None)
+ outspace = cgutils.alloca_once_value(c.builder, null_string)
+
+ # We don't need to set the NULL-terminator because the storage
+ # is already zero-filled.
+ cgutils.memcpy(c.builder,
+ c.builder.bitcast(outspace, buffer.type),
+ buffer, size)
+
+ ret = c.builder.load(outspace)
+ return NativeValue(ret, is_error=c.builder.not_(ok))
+
+
+@box(types.Bytes)
+def box_bytes(typ, val, c):
+ obj = c.context.make_helper(c.builder, typ, val)
+ ret = c.pyapi.bytes_from_string_and_size(obj.data, obj.nitems)
+ c.context.nrt.decref(c.builder, typ, val)
+ return ret
+
+
+@box(types.CharSeq)
+def box_charseq(typ, val, c):
+ rawptr = cgutils.alloca_once_value(c.builder, value=val)
+ strptr = c.builder.bitcast(rawptr, c.pyapi.cstring)
+ fullsize = c.context.get_constant(types.intp, typ.count)
+ zero = fullsize.type(0)
+ one = fullsize.type(1)
+ count = cgutils.alloca_once_value(c.builder, zero)
+
+ # Find the length of the string, mimicking Numpy's behaviour:
+ # search for the last non-null byte in the underlying storage
+ # (e.g. b'A\0\0B\0\0\0' will return the logical string b'A\0\0B')
+ with cgutils.loop_nest(c.builder, [fullsize], fullsize.type) as [idx]:
+ # Get char at idx
+ ch = c.builder.load(c.builder.gep(strptr, [idx]))
+ # If the char is a non-null-byte, store the next index as count
+ with c.builder.if_then(cgutils.is_not_null(c.builder, ch)):
+ c.builder.store(c.builder.add(idx, one), count)
+
+ strlen = c.builder.load(count)
+ return c.pyapi.bytes_from_string_and_size(strptr, strlen)
+
+
+@unbox(types.CharSeq)
+def unbox_charseq(typ, obj, c):
+ lty = c.context.get_value_type(typ)
+ ok, buffer, size = c.pyapi.string_as_string_and_size(obj)
+
+ # If conversion is ok, copy the buffer to the output storage.
+ with cgutils.if_likely(c.builder, ok):
+ # Check if the returned string size fits in the charseq
+ storage_size = ir.Constant(size.type, typ.count)
+ size_fits = c.builder.icmp_unsigned("<=", size, storage_size)
+
+ # Allow truncation of string
+ size = c.builder.select(size_fits, size, storage_size)
+
+ # Initialize output to zero bytes
+ null_string = ir.Constant(lty, None)
+ outspace = cgutils.alloca_once_value(c.builder, null_string)
+
+ # We don't need to set the NULL-terminator because the storage
+ # is already zero-filled.
+ cgutils.memcpy(c.builder,
+ c.builder.bitcast(outspace, buffer.type),
+ buffer, size)
+
+ ret = c.builder.load(outspace)
+ return NativeValue(ret, is_error=c.builder.not_(ok))
+
+
+@box(types.Optional)
+def box_optional(typ, val, c):
+ optval = c.context.make_helper(c.builder, typ, val)
+ ret = cgutils.alloca_once_value(c.builder, c.pyapi.borrow_none())
+ with c.builder.if_else(optval.valid) as (then, otherwise):
+ with then:
+ validres = c.box(typ.type, optval.data)
+ c.builder.store(validres, ret)
+ with otherwise:
+ c.builder.store(c.pyapi.make_none(), ret)
+ return c.builder.load(ret)
+
+
+@unbox(types.Optional)
+def unbox_optional(typ, obj, c):
+ """
+ Convert object *obj* to a native optional structure.
+ """
+ noneval = c.context.make_optional_none(c.builder, typ.type)
+ is_not_none = c.builder.icmp_signed('!=', obj, c.pyapi.borrow_none())
+
+ retptr = cgutils.alloca_once(c.builder, noneval.type)
+ errptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+
+ with c.builder.if_else(is_not_none) as (then, orelse):
+ with then:
+ native = c.unbox(typ.type, obj)
+ just = c.context.make_optional_value(c.builder,
+ typ.type, native.value)
+ c.builder.store(just, retptr)
+ c.builder.store(native.is_error, errptr)
+
+ with orelse:
+ c.builder.store(noneval, retptr)
+
+ if native.cleanup is not None:
+ def cleanup():
+ with c.builder.if_then(is_not_none):
+ native.cleanup()
+ else:
+ cleanup = None
+
+ ret = c.builder.load(retptr)
+ return NativeValue(ret, is_error=c.builder.load(errptr),
+ cleanup=cleanup)
+
+
+@unbox(types.SliceType)
+def unbox_slice(typ, obj, c):
+ """
+ Convert object *obj* to a native slice structure.
+ """
+ from numba.cpython import slicing
+ ok, start, stop, step = c.pyapi.slice_as_ints(obj)
+ sli = c.context.make_helper(c.builder, typ)
+ sli.start = start
+ sli.stop = stop
+ sli.step = step
+ return NativeValue(sli._getvalue(), is_error=c.builder.not_(ok))
+
+@box(types.SliceLiteral)
+def box_slice_literal(typ, val, c):
+ # Check for integer overflows at compile time.
+ slice_lit = typ.literal_value
+ for field_name in ("start", "stop", "step"):
+ field_obj = getattr(slice_lit, field_name)
+ if isinstance(field_obj, int):
+ try:
+ typeof(field_obj, Purpose)
+ except ValueError as e:
+ raise ValueError((
+ f"Unable to create literal slice. "
+ f"Error encountered with {field_name} "
+ f"attribute. {str(e)}")
+ )
+
+ py_ctor, py_args = typ.literal_value.__reduce__()
+ serialized_ctor = c.pyapi.serialize_object(py_ctor)
+ serialized_args = c.pyapi.serialize_object(py_args)
+ ctor = c.pyapi.unserialize(serialized_ctor)
+ args = c.pyapi.unserialize(serialized_args)
+ obj = c.pyapi.call(ctor, args)
+ c.pyapi.decref(ctor)
+ c.pyapi.decref(args)
+ return obj
+
+@unbox(types.StringLiteral)
+def unbox_string_literal(typ, obj, c):
+ # A string literal is a dummy value
+ return NativeValue(c.context.get_dummy_value())
+
+#
+# Collections
+#
+
+# NOTE: boxing functions are supposed to steal any NRT references in
+# the given native value.
+
+@box(types.Array)
+def box_array(typ, val, c):
+ nativearycls = c.context.make_array(typ)
+ nativeary = nativearycls(c.context, c.builder, value=val)
+ if c.context.enable_nrt:
+ np_dtype = numpy_support.as_dtype(typ.dtype)
+ dtypeptr = c.env_manager.read_const(c.env_manager.add_const(np_dtype))
+ newary = c.pyapi.nrt_adapt_ndarray_to_python(typ, val, dtypeptr)
+ # Steals NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return newary
+ else:
+ parent = nativeary.parent
+ c.pyapi.incref(parent)
+ return parent
+
+
+@unbox(types.Buffer)
+def unbox_buffer(typ, obj, c):
+ """
+ Convert a Py_buffer-providing object to a native array structure.
+ """
+ buf = c.pyapi.alloca_buffer()
+ res = c.pyapi.get_buffer(obj, buf)
+ is_error = cgutils.is_not_null(c.builder, res)
+
+ nativearycls = c.context.make_array(typ)
+ nativeary = nativearycls(c.context, c.builder)
+ aryptr = nativeary._getpointer()
+
+ with cgutils.if_likely(c.builder, c.builder.not_(is_error)):
+ ptr = c.builder.bitcast(aryptr, c.pyapi.voidptr)
+ if c.context.enable_nrt:
+ c.pyapi.nrt_adapt_buffer_from_python(buf, ptr)
+ else:
+ c.pyapi.numba_buffer_adaptor(buf, ptr)
+
+ def cleanup():
+ c.pyapi.release_buffer(buf)
+
+ return NativeValue(c.builder.load(aryptr), is_error=is_error,
+ cleanup=cleanup)
+
+@unbox(types.Array)
+def unbox_array(typ, obj, c):
+ """
+ Convert a Numpy array object to a native array structure.
+ """
+ # This is necessary because unbox_buffer() does not work on some
+ # dtypes, e.g. datetime64 and timedelta64.
+ # TODO check matching dtype.
+ # currently, mismatching dtype will still work and causes
+ # potential memory corruption
+ nativearycls = c.context.make_array(typ)
+ nativeary = nativearycls(c.context, c.builder)
+ aryptr = nativeary._getpointer()
+
+ ptr = c.builder.bitcast(aryptr, c.pyapi.voidptr)
+ if c.context.enable_nrt:
+ errcode = c.pyapi.nrt_adapt_ndarray_from_python(obj, ptr)
+ else:
+ errcode = c.pyapi.numba_array_adaptor(obj, ptr)
+
+ # TODO: here we have minimal typechecking by the itemsize.
+ # need to do better
+ try:
+ expected_itemsize = numpy_support.as_dtype(typ.dtype).itemsize
+ except NumbaNotImplementedError:
+ # Don't check types that can't be `as_dtype()`-ed
+ itemsize_mismatch = cgutils.false_bit
+ else:
+ expected_itemsize = nativeary.itemsize.type(expected_itemsize)
+ itemsize_mismatch = c.builder.icmp_unsigned(
+ '!=',
+ nativeary.itemsize,
+ expected_itemsize,
+ )
+
+ failed = c.builder.or_(
+ cgutils.is_not_null(c.builder, errcode),
+ itemsize_mismatch,
+ )
+ # Handle error
+ with c.builder.if_then(failed, likely=False):
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "can't unbox array from PyObject into "
+ "native value. The object maybe of a "
+ "different type")
+ return NativeValue(c.builder.load(aryptr), is_error=failed)
+
+
+@box(types.Tuple)
+@box(types.UniTuple)
+def box_tuple(typ, val, c):
+ """
+ Convert native array or structure *val* to a tuple object.
+ """
+ tuple_val = c.pyapi.tuple_new(typ.count)
+
+ for i, dtype in enumerate(typ):
+ item = c.builder.extract_value(val, i)
+ obj = c.box(dtype, item)
+ c.pyapi.tuple_setitem(tuple_val, i, obj)
+
+ return tuple_val
+
+@box(types.NamedTuple)
+@box(types.NamedUniTuple)
+def box_namedtuple(typ, val, c):
+ """
+ Convert native array or structure *val* to a namedtuple object.
+ """
+ cls_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ.instance_class))
+ tuple_obj = box_tuple(typ, val, c)
+ obj = c.pyapi.call(cls_obj, tuple_obj)
+ c.pyapi.decref(cls_obj)
+ c.pyapi.decref(tuple_obj)
+ return obj
+
+
+@unbox(types.BaseTuple)
+def unbox_tuple(typ, obj, c):
+ """
+ Convert tuple *obj* to a native array (if homogeneous) or structure.
+ """
+ n = len(typ)
+ values = []
+ cleanups = []
+ lty = c.context.get_value_type(typ)
+
+ is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ value_ptr = cgutils.alloca_once(c.builder, lty)
+
+ # Issue #1638: need to check the tuple size
+ actual_size = c.pyapi.tuple_size(obj)
+ size_matches = c.builder.icmp_unsigned('==', actual_size,
+ ir.Constant(actual_size.type, n))
+ with c.builder.if_then(c.builder.not_(size_matches), likely=False):
+ c.pyapi.err_format(
+ "PyExc_ValueError",
+ "size mismatch for tuple, expected %d element(s) but got %%zd" % (n,),
+ actual_size)
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+
+ # We unbox the items even if not `size_matches`, to avoid issues with
+ # the generated IR (instruction doesn't dominate all uses)
+ for i, eltype in enumerate(typ):
+ elem = c.pyapi.tuple_getitem(obj, i)
+ native = c.unbox(eltype, elem)
+ values.append(native.value)
+ with c.builder.if_then(native.is_error, likely=False):
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+ if native.cleanup is not None:
+ cleanups.append(native.cleanup)
+
+ value = c.context.make_tuple(c.builder, typ, values)
+ c.builder.store(value, value_ptr)
+
+ if cleanups:
+ with c.builder.if_then(size_matches, likely=True):
+ def cleanup():
+ for func in reversed(cleanups):
+ func()
+ else:
+ cleanup = None
+
+ return NativeValue(c.builder.load(value_ptr), cleanup=cleanup,
+ is_error=c.builder.load(is_error_ptr))
+
+
+@box(types.List)
+def box_list(typ, val, c):
+ """
+ Convert native list *val* to a list object.
+ """
+ list = listobj.ListInstance(c.context, c.builder, typ, val)
+ obj = list.parent
+ res = cgutils.alloca_once_value(c.builder, obj)
+ with c.builder.if_else(cgutils.is_not_null(c.builder, obj)) as (has_parent, otherwise):
+ with has_parent:
+ # List is actually reflected => return the original object
+ # (note not all list instances whose *type* is reflected are
+ # actually reflected; see numba.tests.test_lists for an example)
+ c.pyapi.incref(obj)
+
+ with otherwise:
+ # Build a new Python list
+ nitems = list.size
+ obj = c.pyapi.list_new(nitems)
+ with c.builder.if_then(cgutils.is_not_null(c.builder, obj),
+ likely=True):
+ with cgutils.for_range(c.builder, nitems) as loop:
+ item = list.getitem(loop.index)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(obj, loop.index, itemobj)
+
+ c.builder.store(obj, res)
+
+ # Steal NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return c.builder.load(res)
+
+
+class _NumbaTypeHelper(object):
+ """A helper for acquiring `numba.typeof` for type checking.
+
+ Usage
+ -----
+
+ # `c` is the boxing context.
+ with _NumbaTypeHelper(c) as nth:
+ # This contextmanager maintains the lifetime of the `numba.typeof`
+ # function.
+ the_numba_type = nth.typeof(some_object)
+ # Do work on the type object
+ do_checks(the_numba_type)
+ # Cleanup
+ c.pyapi.decref(the_numba_type)
+ # At this point *nth* should not be used.
+ """
+ def __init__(self, c):
+ self.c = c
+
+ def __enter__(self):
+ c = self.c
+ numba_name = c.context.insert_const_string(c.builder.module, 'numba')
+ numba_mod = c.pyapi.import_module(numba_name)
+ typeof_fn = c.pyapi.object_getattr_string(numba_mod, 'typeof')
+ self.typeof_fn = typeof_fn
+ c.pyapi.decref(numba_mod)
+ return self
+
+ def __exit__(self, *args, **kwargs):
+ c = self.c
+ c.pyapi.decref(self.typeof_fn)
+
+ def typeof(self, obj):
+ res = self.c.pyapi.call_function_objargs(self.typeof_fn, [obj])
+ return res
+
+
+def _python_list_to_native(typ, obj, c, size, listptr, errorptr):
+ """
+ Construct a new native list from a Python list.
+ """
+ def check_element_type(nth, itemobj, expected_typobj):
+ typobj = nth.typeof(itemobj)
+ # Check if *typobj* is NULL
+ with c.builder.if_then(
+ cgutils.is_null(c.builder, typobj),
+ likely=False,
+ ):
+ c.builder.store(cgutils.true_bit, errorptr)
+ loop.do_break()
+ # Mandate that objects all have the same exact type
+ type_mismatch = c.builder.icmp_signed('!=', typobj, expected_typobj)
+
+ with c.builder.if_then(type_mismatch, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ c.pyapi.err_format(
+ "PyExc_TypeError",
+ "can't unbox heterogeneous list: %S != %S",
+ expected_typobj, typobj,
+ )
+ c.pyapi.decref(typobj)
+ loop.do_break()
+ c.pyapi.decref(typobj)
+
+ # Allocate a new native list
+ ok, list = listobj.ListInstance.allocate_ex(c.context, c.builder, typ, size)
+ with c.builder.if_else(ok, likely=True) as (if_ok, if_not_ok):
+ with if_ok:
+ list.size = size
+ zero = ir.Constant(size.type, 0)
+ with c.builder.if_then(c.builder.icmp_signed('>', size, zero),
+ likely=True):
+ # Traverse Python list and unbox objects into native list
+ with _NumbaTypeHelper(c) as nth:
+ # Note: *expected_typobj* can't be NULL
+ expected_typobj = nth.typeof(c.pyapi.list_getitem(obj, zero))
+ with cgutils.for_range(c.builder, size) as loop:
+ itemobj = c.pyapi.list_getitem(obj, loop.index)
+ check_element_type(nth, itemobj, expected_typobj)
+ # XXX we don't call native cleanup for each
+ # list element, since that would require keeping
+ # of which unboxings have been successful.
+ native = c.unbox(typ.dtype, itemobj)
+ with c.builder.if_then(native.is_error, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ loop.do_break()
+ # The reference is borrowed so incref=False
+ list.setitem(loop.index, native.value, incref=False)
+ c.pyapi.decref(expected_typobj)
+ if typ.reflected:
+ list.parent = obj
+ # Stuff meminfo pointer into the Python object for
+ # later reuse.
+ with c.builder.if_then(c.builder.not_(c.builder.load(errorptr)),
+ likely=False):
+ c.pyapi.object_set_private_data(obj, list.meminfo)
+ list.set_dirty(False)
+ c.builder.store(list.value, listptr)
+
+ with if_not_ok:
+ c.builder.store(cgutils.true_bit, errorptr)
+
+ # If an error occurred, drop the whole native list
+ with c.builder.if_then(c.builder.load(errorptr)):
+ c.context.nrt.decref(c.builder, typ, list.value)
+
+
+@unbox(types.List)
+def unbox_list(typ, obj, c):
+ """
+ Convert list *obj* to a native list.
+
+ If list was previously unboxed, we reuse the existing native list
+ to ensure consistency.
+ """
+ size = c.pyapi.list_size(obj)
+
+ errorptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ listptr = cgutils.alloca_once(c.builder, c.context.get_value_type(typ))
+
+ # See if the list was previously unboxed, if so, re-use the meminfo.
+ ptr = c.pyapi.object_get_private_data(obj)
+
+ with c.builder.if_else(cgutils.is_not_null(c.builder, ptr)) \
+ as (has_meminfo, otherwise):
+
+ with has_meminfo:
+ # List was previously unboxed => reuse meminfo
+ list = listobj.ListInstance.from_meminfo(c.context, c.builder, typ, ptr)
+ list.size = size
+ if typ.reflected:
+ list.parent = obj
+ c.builder.store(list.value, listptr)
+
+ with otherwise:
+ _python_list_to_native(typ, obj, c, size, listptr, errorptr)
+
+ def cleanup():
+ # Clean up the associated pointer, as the meminfo is now invalid.
+ c.pyapi.object_reset_private_data(obj)
+
+ return NativeValue(c.builder.load(listptr),
+ is_error=c.builder.load(errorptr),
+ cleanup=cleanup)
+
+
+@reflect(types.List)
+def reflect_list(typ, val, c):
+ """
+ Reflect the native list's contents into the Python object.
+ """
+ if not typ.reflected:
+ return
+ if typ.dtype.reflected:
+ msg = "cannot reflect element of reflected container: {}\n".format(typ)
+ raise TypeError(msg)
+
+ list = listobj.ListInstance(c.context, c.builder, typ, val)
+ with c.builder.if_then(list.dirty, likely=False):
+ obj = list.parent
+ size = c.pyapi.list_size(obj)
+ new_size = list.size
+ diff = c.builder.sub(new_size, size)
+ diff_gt_0 = c.builder.icmp_signed('>=', diff,
+ ir.Constant(diff.type, 0))
+ with c.builder.if_else(diff_gt_0) as (if_grow, if_shrink):
+ # XXX no error checking below
+ with if_grow:
+ # First overwrite existing items
+ with cgutils.for_range(c.builder, size) as loop:
+ item = list.getitem(loop.index)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(obj, loop.index, itemobj)
+ # Then add missing items
+ with cgutils.for_range(c.builder, diff) as loop:
+ idx = c.builder.add(size, loop.index)
+ item = list.getitem(idx)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_append(obj, itemobj)
+ c.pyapi.decref(itemobj)
+
+ with if_shrink:
+ # First delete list tail
+ c.pyapi.list_setslice(obj, new_size, size, None)
+ # Then overwrite remaining items
+ with cgutils.for_range(c.builder, new_size) as loop:
+ item = list.getitem(loop.index)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(obj, loop.index, itemobj)
+
+ # Mark the list clean, in case it is reflected twice
+ list.set_dirty(False)
+
+
+def _python_set_to_native(typ, obj, c, size, setptr, errorptr):
+ """
+ Construct a new native set from a Python set.
+ """
+ # Allocate a new native set
+ ok, inst = setobj.SetInstance.allocate_ex(c.context, c.builder, typ, size)
+ with c.builder.if_else(ok, likely=True) as (if_ok, if_not_ok):
+ with if_ok:
+ # Traverse Python set and unbox objects into native set
+ typobjptr = cgutils.alloca_once_value(c.builder,
+ ir.Constant(c.pyapi.pyobj, None))
+
+ with c.pyapi.set_iterate(obj) as loop:
+ itemobj = loop.value
+ # Mandate that objects all have the same exact type
+ typobj = c.pyapi.get_type(itemobj)
+ expected_typobj = c.builder.load(typobjptr)
+
+ with c.builder.if_else(
+ cgutils.is_null(c.builder, expected_typobj),
+ likely=False) as (if_first, if_not_first):
+ with if_first:
+ # First iteration => store item type
+ c.builder.store(typobj, typobjptr)
+ with if_not_first:
+ # Otherwise, check item type
+ type_mismatch = c.builder.icmp_signed('!=', typobj,
+ expected_typobj)
+ with c.builder.if_then(type_mismatch, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "can't unbox heterogeneous set")
+ loop.do_break()
+
+ # XXX we don't call native cleanup for each set element,
+ # since that would require keeping track
+ # of which unboxings have been successful.
+ native = c.unbox(typ.dtype, itemobj)
+ with c.builder.if_then(native.is_error, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ inst.add_pyapi(c.pyapi, native.value, do_resize=False)
+
+ if typ.reflected:
+ inst.parent = obj
+ # Associate meminfo pointer with the Python object for later reuse.
+ with c.builder.if_then(c.builder.not_(c.builder.load(errorptr)),
+ likely=False):
+ c.pyapi.object_set_private_data(obj, inst.meminfo)
+ inst.set_dirty(False)
+ c.builder.store(inst.value, setptr)
+
+ with if_not_ok:
+ c.builder.store(cgutils.true_bit, errorptr)
+
+ # If an error occurred, drop the whole native set
+ with c.builder.if_then(c.builder.load(errorptr)):
+ c.context.nrt.decref(c.builder, typ, inst.value)
+
+
+@unbox(types.Set)
+def unbox_set(typ, obj, c):
+ """
+ Convert set *obj* to a native set.
+
+ If set was previously unboxed, we reuse the existing native set
+ to ensure consistency.
+ """
+ size = c.pyapi.set_size(obj)
+
+ errorptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ setptr = cgutils.alloca_once(c.builder, c.context.get_value_type(typ))
+
+ # See if the set was previously unboxed, if so, re-use the meminfo.
+ ptr = c.pyapi.object_get_private_data(obj)
+
+ with c.builder.if_else(cgutils.is_not_null(c.builder, ptr)) \
+ as (has_meminfo, otherwise):
+
+ with has_meminfo:
+ # Set was previously unboxed => reuse meminfo
+ inst = setobj.SetInstance.from_meminfo(c.context, c.builder, typ, ptr)
+ if typ.reflected:
+ inst.parent = obj
+ c.builder.store(inst.value, setptr)
+
+ with otherwise:
+ _python_set_to_native(typ, obj, c, size, setptr, errorptr)
+
+ def cleanup():
+ # Clean up the associated pointer, as the meminfo is now invalid.
+ c.pyapi.object_reset_private_data(obj)
+
+ return NativeValue(c.builder.load(setptr),
+ is_error=c.builder.load(errorptr),
+ cleanup=cleanup)
+
+
+def _native_set_to_python_list(typ, payload, c):
+ """
+ Create a Python list from a native set's items.
+ """
+ nitems = payload.used
+ listobj = c.pyapi.list_new(nitems)
+ ok = cgutils.is_not_null(c.builder, listobj)
+ with c.builder.if_then(ok, likely=True):
+ index = cgutils.alloca_once_value(c.builder,
+ ir.Constant(nitems.type, 0))
+ with payload._iterate() as loop:
+ i = c.builder.load(index)
+ item = loop.entry.key
+ c.context.nrt.incref(c.builder, typ.dtype, item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(listobj, i, itemobj)
+ i = c.builder.add(i, ir.Constant(i.type, 1))
+ c.builder.store(i, index)
+
+ return ok, listobj
+
+
+@box(types.Set)
+def box_set(typ, val, c):
+ """
+ Convert native set *val* to a set object.
+ """
+ inst = setobj.SetInstance(c.context, c.builder, typ, val)
+ obj = inst.parent
+ res = cgutils.alloca_once_value(c.builder, obj)
+
+ with c.builder.if_else(cgutils.is_not_null(c.builder, obj)) as (has_parent, otherwise):
+ with has_parent:
+ # Set is actually reflected => return the original object
+ # (note not all set instances whose *type* is reflected are
+ # actually reflected; see numba.tests.test_sets for an example)
+ c.pyapi.incref(obj)
+
+ with otherwise:
+ # Build a new Python list and then create a set from that
+ payload = inst.payload
+ ok, listobj = _native_set_to_python_list(typ, payload, c)
+ with c.builder.if_then(ok, likely=True):
+ obj = c.pyapi.set_new(listobj)
+ c.pyapi.decref(listobj)
+ c.builder.store(obj, res)
+
+ # Steal NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return c.builder.load(res)
+
+@reflect(types.Set)
+def reflect_set(typ, val, c):
+ """
+ Reflect the native set's contents into the Python object.
+ """
+ if not typ.reflected:
+ return
+ inst = setobj.SetInstance(c.context, c.builder, typ, val)
+ payload = inst.payload
+
+ with c.builder.if_then(payload.dirty, likely=False):
+ obj = inst.parent
+ # XXX errors are not dealt with below
+ c.pyapi.set_clear(obj)
+
+ # Build a new Python list and then update the set with that
+ ok, listobj = _native_set_to_python_list(typ, payload, c)
+ with c.builder.if_then(ok, likely=True):
+ c.pyapi.set_update(obj, listobj)
+ c.pyapi.decref(listobj)
+
+ # Mark the set clean, in case it is reflected twice
+ inst.set_dirty(False)
+
+
+#
+# Other types
+#
+
+@box(types.Generator)
+def box_generator(typ, val, c):
+ return c.pyapi.from_native_generator(val, typ, c.env_manager.env_ptr)
+
+@unbox(types.Generator)
+def unbox_generator(typ, obj, c):
+ return c.pyapi.to_native_generator(obj, typ)
+
+
+@box(types.DType)
+def box_dtype(typ, val, c):
+ np_dtype = numpy_support.as_dtype(typ.dtype)
+ return c.pyapi.unserialize(c.pyapi.serialize_object(np_dtype))
+
+@unbox(types.DType)
+def unbox_dtype(typ, val, c):
+ return NativeValue(c.context.get_dummy_value())
+
+
+@box(types.NumberClass)
+def box_number_class(typ, val, c):
+ np_dtype = numpy_support.as_dtype(typ.dtype)
+ return c.pyapi.unserialize(c.pyapi.serialize_object(np_dtype))
+
+@unbox(types.NumberClass)
+def unbox_number_class(typ, val, c):
+ return NativeValue(c.context.get_dummy_value())
+
+
+@box(types.PyObject)
+@box(types.Object)
+def box_pyobject(typ, val, c):
+ return val
+
+@unbox(types.PyObject)
+@unbox(types.Object)
+def unbox_pyobject(typ, obj, c):
+ return NativeValue(obj)
+
+
+@unbox(types.ExternalFunctionPointer)
+def unbox_funcptr(typ, obj, c):
+ if typ.get_pointer is None:
+ raise NotImplementedError(typ)
+
+ # Call get_pointer() on the object to get the raw pointer value
+ ptrty = c.context.get_function_pointer_type(typ)
+ ret = cgutils.alloca_once_value(c.builder,
+ ir.Constant(ptrty, None),
+ name='fnptr')
+ ser = c.pyapi.serialize_object(typ.get_pointer)
+ get_pointer = c.pyapi.unserialize(ser)
+ with cgutils.if_likely(c.builder,
+ cgutils.is_not_null(c.builder, get_pointer)):
+ intobj = c.pyapi.call_function_objargs(get_pointer, (obj,))
+ c.pyapi.decref(get_pointer)
+ with cgutils.if_likely(c.builder,
+ cgutils.is_not_null(c.builder, intobj)):
+ ptr = c.pyapi.long_as_voidptr(intobj)
+ c.pyapi.decref(intobj)
+ c.builder.store(c.builder.bitcast(ptr, ptrty), ret)
+ return NativeValue(c.builder.load(ret), is_error=c.pyapi.c_api_error())
+
+@box(types.DeferredType)
+def box_deferred(typ, val, c):
+ out = c.pyapi.from_native_value(typ.get(),
+ c.builder.extract_value(val, [0]),
+ env_manager=c.env_manager)
+ return out
+
+
+@unbox(types.DeferredType)
+def unbox_deferred(typ, obj, c):
+ native_value = c.pyapi.to_native_value(typ.get(), obj)
+ model = c.context.data_model_manager[typ]
+ res = model.set(c.builder, model.make_uninitialized(), native_value.value)
+ return NativeValue(res, is_error=native_value.is_error,
+ cleanup=native_value.cleanup)
+
+
+@unbox(types.Dispatcher)
+def unbox_dispatcher(typ, obj, c):
+ # In native code, Dispatcher types can be casted to FunctionType.
+ return NativeValue(obj)
+
+
+@box(types.Dispatcher)
+def box_pyobject(typ, val, c):
+ c.pyapi.incref(val)
+ return val
+
+
+def unbox_unsupported(typ, obj, c):
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "can't unbox {!r} type".format(typ))
+ res = c.context.get_constant_null(typ)
+ return NativeValue(res, is_error=cgutils.true_bit)
+
+
+def box_unsupported(typ, val, c):
+ msg = "cannot convert native %s to Python object" % (typ,)
+ c.pyapi.err_set_string("PyExc_TypeError", msg)
+ res = c.pyapi.get_null_object()
+ return res
+
+
+@box(types.Literal)
+def box_literal(typ, val, c):
+ # Const type contains the python object of the constant value,
+ # which we can directly return.
+ retval = typ.literal_value
+ # Serialize the value into the IR
+ return c.pyapi.unserialize(c.pyapi.serialize_object(retval))
+
+
+@box(types.MemInfoPointer)
+def box_meminfo_pointer(typ, val, c):
+ return c.pyapi.nrt_meminfo_as_pyobject(val)
+
+
+@unbox(types.MemInfoPointer)
+def unbox_meminfo_pointer(typ, obj, c):
+ res = c.pyapi.nrt_meminfo_from_pyobject(obj)
+ errored = cgutils.is_null(c.builder, res)
+ return NativeValue(res, is_error=errored)
+
+@unbox(types.TypeRef)
+def unbox_typeref(typ, val, c):
+ return NativeValue(c.context.get_dummy_value(), is_error=cgutils.false_bit)
+
+
+@box(types.LiteralStrKeyDict)
+def box_LiteralStrKeyDict(typ, val, c):
+ return box_unsupported(typ, val, c)
+
+
+# Original implementation at: https://github.com/numba/numba/issues/4499#issuecomment-1063138477
+@unbox(types.NumPyRandomBitGeneratorType)
+def unbox_numpy_random_bitgenerator(typ, obj, c):
+ """
+ The bit_generator instance has a `.ctypes` attr which is a namedtuple
+ with the following members (types):
+ * state_address (Python int)
+ * state (ctypes.c_void_p)
+ * next_uint64 (ctypes.CFunctionType instance)
+ * next_uint32 (ctypes.CFunctionType instance)
+ * next_double (ctypes.CFunctionType instance)
+ * bit_generator (ctypes.c_void_p)
+ """
+
+ is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ extra_refs = []
+
+ def clear_extra_refs():
+ for _ref in extra_refs:
+ c.pyapi.decref(_ref)
+
+ def handle_failure():
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+ clear_extra_refs()
+
+ with ExitStack() as stack:
+
+ def object_getattr_safely(obj, attr):
+ attr_obj = c.pyapi.object_getattr_string(obj, attr)
+ extra_refs.append(attr_obj)
+ return attr_obj
+
+ struct_ptr = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+ struct_ptr.parent = obj
+
+ # Get the .ctypes attr
+ ctypes_binding = object_getattr_safely(obj, 'ctypes')
+ with cgutils.early_exit_if_null(c.builder, stack, ctypes_binding):
+ handle_failure()
+
+ # Look up the "state_address" member and wire it into the struct
+ interface_state_address = object_getattr_safely(
+ ctypes_binding, 'state_address')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_state_address):
+ handle_failure()
+
+ setattr(struct_ptr, 'state_address',
+ c.unbox(types.uintp, interface_state_address).value)
+
+ # Look up the "state" member and wire it into the struct
+ interface_state = object_getattr_safely(ctypes_binding, 'state')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_state):
+ handle_failure()
+
+ interface_state_value = object_getattr_safely(
+ interface_state, 'value')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_state_value):
+ handle_failure()
+ setattr(
+ struct_ptr,
+ 'state',
+ c.unbox(
+ types.uintp,
+ interface_state_value).value)
+
+ # Want to store callable function pointers to these CFunctionTypes, so
+ # import ctypes and use it to cast the CFunctionTypes to c_void_p and
+ # store the results.
+ # First find ctypes.cast, and ctypes.c_void_p
+ ctypes_name = c.context.insert_const_string(c.builder.module, 'ctypes')
+ ctypes_module = c.pyapi.import_module(ctypes_name)
+ extra_refs.append(ctypes_module)
+ with cgutils.early_exit_if_null(c.builder, stack, ctypes_module):
+ handle_failure()
+
+ ct_cast = object_getattr_safely(ctypes_module, 'cast')
+ with cgutils.early_exit_if_null(c.builder, stack, ct_cast):
+ handle_failure()
+
+ ct_voidptr_ty = object_getattr_safely(ctypes_module, 'c_void_p')
+ with cgutils.early_exit_if_null(c.builder, stack, ct_voidptr_ty):
+ handle_failure()
+
+ # This wires in the fnptrs referred to by name
+ def wire_in_fnptrs(name):
+ # Find the CFunctionType function
+ interface_next_fn = c.pyapi.object_getattr_string(
+ ctypes_binding, name)
+
+ extra_refs.append(interface_next_fn)
+ with cgutils.early_exit_if_null(c.builder, stack, interface_next_fn):
+ handle_failure()
+
+ # Want to do ctypes.cast(CFunctionType, ctypes.c_void_p), create an
+ # args tuple for that.
+ args = c.pyapi.tuple_pack([interface_next_fn, ct_voidptr_ty])
+ with cgutils.early_exit_if_null(c.builder, stack, args):
+ handle_failure()
+
+ # Call ctypes.cast()
+ interface_next_fn_casted = c.pyapi.call(ct_cast, args)
+
+ # Fetch the .value attr on the resulting ctypes.c_void_p for storage
+ # in the function pointer slot.
+ interface_next_fn_casted_value = object_getattr_safely(
+ interface_next_fn_casted, 'value')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_next_fn_casted_value):
+ handle_failure()
+
+ # Wire up
+ setattr(struct_ptr, f'fnptr_{name}',
+ c.unbox(types.uintp, interface_next_fn_casted_value).value)
+
+
+ wire_in_fnptrs('next_double')
+ wire_in_fnptrs('next_uint64')
+ wire_in_fnptrs('next_uint32')
+
+ clear_extra_refs()
+
+ return NativeValue(struct_ptr._getvalue(), is_error=c.builder.load(is_error_ptr))
+
+_bit_gen_type = types.NumPyRandomBitGeneratorType('bit_generator')
+
+@unbox(types.NumPyRandomGeneratorType)
+def unbox_numpy_random_generator(typ, obj, c):
+ """
+ Here we're creating a NumPyRandomGeneratorType StructModel with following fields:
+ * ('bit_generator', _bit_gen_type): The unboxed BitGenerator associated with
+ this Generator object instance.
+ * ('parent', types.pyobject): Pointer to the original Generator PyObject.
+ * ('meminfo', types.MemInfoPointer(types.voidptr)): The information about the memory
+ stored at the pointer (to the original Generator PyObject). This is useful for
+ keeping track of reference counts within the Python runtime. Helps prevent cases
+ where deletion happens in Python runtime without NRT being awareness of it.
+ """
+ is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+
+ with ExitStack() as stack:
+ struct_ptr = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+ bit_gen_inst = c.pyapi.object_getattr_string(obj, 'bit_generator')
+ with cgutils.early_exit_if_null(c.builder, stack, bit_gen_inst):
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+ unboxed = c.unbox(_bit_gen_type, bit_gen_inst).value
+ struct_ptr.bit_generator = unboxed
+ struct_ptr.parent = obj
+ NULL = cgutils.voidptr_t(None)
+ struct_ptr.meminfo = c.pyapi.nrt_meminfo_new_from_pyobject(
+ NULL, # there's no data
+ obj, # the python object, the call to nrt_meminfo_new_from_pyobject
+ # will py_incref
+ )
+ c.pyapi.decref(bit_gen_inst)
+
+ return NativeValue(struct_ptr._getvalue(), is_error=c.builder.load(is_error_ptr))
+
+
+@box(types.NumPyRandomGeneratorType)
+def box_numpy_random_generator(typ, val, c):
+ inst = c.context.make_helper(c.builder, typ, val)
+ obj = inst.parent
+ res = cgutils.alloca_once_value(c.builder, obj)
+ c.pyapi.incref(obj)
+ # Steal NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return c.builder.load(res)
diff --git a/venv/lib/python3.10/site-packages/numba/core/object_mode_passes.py b/venv/lib/python3.10/site-packages/numba/core/object_mode_passes.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5b463c14b14e018df3fafdc68e0d7a5ca92489a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/object_mode_passes.py
@@ -0,0 +1,147 @@
+from numba.core import (types, typing, funcdesc, config, pylowering, transforms,
+ errors)
+from numba.core.compiler_machinery import (FunctionPass, LoweringPass,
+ register_pass)
+from collections import defaultdict
+import warnings
+
+
+@register_pass(mutates_CFG=True, analysis_only=False)
+class ObjectModeFrontEnd(FunctionPass):
+ _name = "object_mode_front_end"
+
+ def __init__(self):
+ FunctionPass.__init__(self)
+
+ def _frontend_looplift(self, state):
+ """
+ Loop lifting analysis and transformation
+ """
+ loop_flags = state.flags.copy()
+ outer_flags = state.flags.copy()
+ # Do not recursively loop lift
+ outer_flags.enable_looplift = False
+ loop_flags.enable_looplift = False
+ if not state.flags.enable_pyobject_looplift:
+ loop_flags.enable_pyobject = False
+ loop_flags.enable_ssa = False
+
+ main, loops = transforms.loop_lifting(state.func_ir,
+ typingctx=state.typingctx,
+ targetctx=state.targetctx,
+ locals=state.locals,
+ flags=loop_flags)
+ if loops:
+ # Some loops were extracted
+ if config.DEBUG_FRONTEND or config.DEBUG:
+ for loop in loops:
+ print("Lifting loop", loop.get_source_location())
+ from numba.core.compiler import compile_ir
+ cres = compile_ir(state.typingctx, state.targetctx, main,
+ state.args, state.return_type,
+ outer_flags, state.locals,
+ lifted=tuple(loops), lifted_from=None,
+ is_lifted_loop=True)
+ return cres
+
+ def run_pass(self, state):
+ from numba.core.compiler import _EarlyPipelineCompletion
+ # NOTE: That so much stuff, including going back into the compiler, is
+ # captured in a single pass is not ideal.
+ if state.flags.enable_looplift:
+ assert not state.lifted
+ cres = self._frontend_looplift(state)
+ if cres is not None:
+ raise _EarlyPipelineCompletion(cres)
+
+ # Fallback typing: everything is a python object
+ state.typemap = defaultdict(lambda: types.pyobject)
+ state.calltypes = defaultdict(lambda: types.pyobject)
+ state.return_type = types.pyobject
+ return True
+
+
+@register_pass(mutates_CFG=True, analysis_only=False)
+class ObjectModeBackEnd(LoweringPass):
+
+ _name = "object_mode_back_end"
+
+ def __init__(self):
+ LoweringPass.__init__(self)
+
+ def _py_lowering_stage(self, targetctx, library, interp, flags):
+ fndesc = funcdesc.PythonFunctionDescriptor.from_object_mode_function(
+ interp
+ )
+ with targetctx.push_code_library(library):
+ lower = pylowering.PyLower(targetctx, library, fndesc, interp)
+ lower.lower()
+ if not flags.no_cpython_wrapper:
+ lower.create_cpython_wrapper()
+ env = lower.env
+ call_helper = lower.call_helper
+ del lower
+ from numba.core.compiler import _LowerResult # TODO: move this
+ if flags.no_compile:
+ return _LowerResult(fndesc, call_helper, cfunc=None, env=env)
+ else:
+ # Prepare for execution
+ cfunc = targetctx.get_executable(library, fndesc, env)
+ return _LowerResult(fndesc, call_helper, cfunc=cfunc, env=env)
+
+ def run_pass(self, state):
+ """
+ Lowering for object mode
+ """
+
+ if state.library is None:
+ codegen = state.targetctx.codegen()
+ state.library = codegen.create_library(state.func_id.func_qualname)
+ # Enable object caching upfront, so that the library can
+ # be later serialized.
+ state.library.enable_object_caching()
+
+ def backend_object_mode():
+ """
+ Object mode compilation
+ """
+ if len(state.args) != state.nargs:
+ # append missing
+ # BUG?: What's going on with nargs here?
+ # check state.nargs vs self.nargs on original code
+ state.args = (tuple(state.args) + (types.pyobject,) *
+ (state.nargs - len(state.args)))
+
+ return self._py_lowering_stage(state.targetctx,
+ state.library,
+ state.func_ir,
+ state.flags)
+
+ lowered = backend_object_mode()
+ signature = typing.signature(state.return_type, *state.args)
+ from numba.core.compiler import compile_result
+ state.cr = compile_result(
+ typing_context=state.typingctx,
+ target_context=state.targetctx,
+ entry_point=lowered.cfunc,
+ typing_error=state.status.fail_reason,
+ type_annotation=state.type_annotation,
+ library=state.library,
+ call_helper=lowered.call_helper,
+ signature=signature,
+ objectmode=True,
+ lifted=state.lifted,
+ fndesc=lowered.fndesc,
+ environment=lowered.env,
+ metadata=state.metadata,
+ reload_init=state.reload_init,
+ )
+
+ if state.flags.release_gil:
+ warn_msg = ("Code running in object mode won't allow parallel"
+ " execution despite nogil=True.")
+ warnings.warn_explicit(warn_msg, errors.NumbaWarning,
+ state.func_id.filename,
+ state.func_id.firstlineno)
+
+ return True
diff --git a/venv/lib/python3.10/site-packages/numba/core/old_boxing.py b/venv/lib/python3.10/site-packages/numba/core/old_boxing.py
new file mode 100644
index 0000000000000000000000000000000000000000..0432f35243438ea6efea19e581e2b5c54d74923d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/old_boxing.py
@@ -0,0 +1,1313 @@
+"""
+Boxing and unboxing of native Numba values to / from CPython objects.
+"""
+
+from llvmlite import ir
+
+from numba.core import types, cgutils
+from numba.core.pythonapi import box, unbox, reflect, NativeValue
+from numba.core.errors import NumbaNotImplementedError, TypingError
+from numba.core.typing.typeof import typeof, Purpose
+
+from numba.cpython import setobj, listobj
+from numba.np import numpy_support
+from contextlib import contextmanager, ExitStack
+
+
+#
+# Scalar types
+#
+
+@box(types.Boolean)
+def box_bool(typ, val, c):
+ return c.pyapi.bool_from_bool(val)
+
+@unbox(types.Boolean)
+def unbox_boolean(typ, obj, c):
+ istrue = c.pyapi.object_istrue(obj)
+ zero = ir.Constant(istrue.type, 0)
+ val = c.builder.icmp_signed('!=', istrue, zero)
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.IntegerLiteral)
+@box(types.BooleanLiteral)
+def box_literal_integer(typ, val, c):
+ val = c.context.cast(c.builder, val, typ, typ.literal_type)
+ return c.box(typ.literal_type, val)
+
+
+@box(types.Integer)
+def box_integer(typ, val, c):
+ if typ.signed:
+ ival = c.builder.sext(val, c.pyapi.longlong)
+ return c.pyapi.long_from_longlong(ival)
+ else:
+ ullval = c.builder.zext(val, c.pyapi.ulonglong)
+ return c.pyapi.long_from_ulonglong(ullval)
+
+@unbox(types.Integer)
+def unbox_integer(typ, obj, c):
+ ll_type = c.context.get_argument_type(typ)
+ val = cgutils.alloca_once(c.builder, ll_type)
+ longobj = c.pyapi.number_long(obj)
+ with c.pyapi.if_object_ok(longobj):
+ if typ.signed:
+ llval = c.pyapi.long_as_longlong(longobj)
+ else:
+ llval = c.pyapi.long_as_ulonglong(longobj)
+ c.pyapi.decref(longobj)
+ c.builder.store(c.builder.trunc(llval, ll_type), val)
+ return NativeValue(c.builder.load(val),
+ is_error=c.pyapi.c_api_error())
+
+
+@box(types.Float)
+def box_float(typ, val, c):
+ if typ == types.float32:
+ dbval = c.builder.fpext(val, c.pyapi.double)
+ else:
+ assert typ == types.float64
+ dbval = val
+ return c.pyapi.float_from_double(dbval)
+
+@unbox(types.Float)
+def unbox_float(typ, obj, c):
+ fobj = c.pyapi.number_float(obj)
+ dbval = c.pyapi.float_as_double(fobj)
+ c.pyapi.decref(fobj)
+ if typ == types.float32:
+ val = c.builder.fptrunc(dbval,
+ c.context.get_argument_type(typ))
+ else:
+ assert typ == types.float64
+ val = dbval
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.Complex)
+def box_complex(typ, val, c):
+ cval = c.context.make_complex(c.builder, typ, value=val)
+
+ if typ == types.complex64:
+ freal = c.builder.fpext(cval.real, c.pyapi.double)
+ fimag = c.builder.fpext(cval.imag, c.pyapi.double)
+ else:
+ assert typ == types.complex128
+ freal, fimag = cval.real, cval.imag
+ return c.pyapi.complex_from_doubles(freal, fimag)
+
+@unbox(types.Complex)
+def unbox_complex(typ, obj, c):
+ # First unbox to complex128, since that's what CPython gives us
+ c128 = c.context.make_complex(c.builder, types.complex128)
+ ok = c.pyapi.complex_adaptor(obj, c128._getpointer())
+ failed = cgutils.is_false(c.builder, ok)
+
+ with cgutils.if_unlikely(c.builder, failed):
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "conversion to %s failed" % (typ,))
+
+ if typ == types.complex64:
+ # Downcast to complex64 if necessary
+ cplx = c.context.make_complex(c.builder, typ)
+ cplx.real = c.context.cast(c.builder, c128.real,
+ types.float64, types.float32)
+ cplx.imag = c.context.cast(c.builder, c128.imag,
+ types.float64, types.float32)
+ else:
+ assert typ == types.complex128
+ cplx = c128
+ return NativeValue(cplx._getvalue(), is_error=failed)
+
+
+@box(types.NoneType)
+def box_none(typ, val, c):
+ return c.pyapi.make_none()
+
+@unbox(types.NoneType)
+@unbox(types.EllipsisType)
+def unbox_none(typ, val, c):
+ return NativeValue(c.context.get_dummy_value())
+
+
+@box(types.NPDatetime)
+def box_npdatetime(typ, val, c):
+ return c.pyapi.create_np_datetime(val, typ.unit_code)
+
+@unbox(types.NPDatetime)
+def unbox_npdatetime(typ, obj, c):
+ val = c.pyapi.extract_np_datetime(obj)
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.NPTimedelta)
+def box_nptimedelta(typ, val, c):
+ return c.pyapi.create_np_timedelta(val, typ.unit_code)
+
+@unbox(types.NPTimedelta)
+def unbox_nptimedelta(typ, obj, c):
+ val = c.pyapi.extract_np_timedelta(obj)
+ return NativeValue(val, is_error=c.pyapi.c_api_error())
+
+
+@box(types.RawPointer)
+def box_raw_pointer(typ, val, c):
+ """
+ Convert a raw pointer to a Python int.
+ """
+ ll_intp = c.context.get_value_type(types.uintp)
+ addr = c.builder.ptrtoint(val, ll_intp)
+ return c.box(types.uintp, addr)
+
+
+@box(types.EnumMember)
+def box_enum(typ, val, c):
+ """
+ Fetch an enum member given its native value.
+ """
+ valobj = c.box(typ.dtype, val)
+ # Call the enum class with the value object
+ cls_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ.instance_class))
+ return c.pyapi.call_function_objargs(cls_obj, (valobj,))
+
+
+@unbox(types.EnumMember)
+def unbox_enum(typ, obj, c):
+ """
+ Convert an enum member's value to its native value.
+ """
+ valobj = c.pyapi.object_getattr_string(obj, "value")
+ return c.unbox(typ.dtype, valobj)
+
+
+@box(types.UndefVar)
+def box_undefvar(typ, val, c):
+ """This type cannot be boxed, there's no Python equivalent"""
+ msg = ("UndefVar type cannot be boxed, there is no Python equivalent of "
+ "this type.")
+ raise TypingError(msg)
+
+#
+# Composite types
+#
+
+@box(types.Record)
+def box_record(typ, val, c):
+ # Note we will create a copy of the record
+ # This is the only safe way.
+ size = ir.Constant(ir.IntType(32), val.type.pointee.count)
+ ptr = c.builder.bitcast(val, ir.PointerType(ir.IntType(8)))
+ return c.pyapi.recreate_record(ptr, size, typ.dtype, c.env_manager)
+
+
+@unbox(types.Record)
+def unbox_record(typ, obj, c):
+ buf = c.pyapi.alloca_buffer()
+ ptr = c.pyapi.extract_record_data(obj, buf)
+ is_error = cgutils.is_null(c.builder, ptr)
+
+ ltyp = c.context.get_value_type(typ)
+ val = c.builder.bitcast(ptr, ltyp)
+
+ def cleanup():
+ c.pyapi.release_buffer(buf)
+ return NativeValue(val, cleanup=cleanup, is_error=is_error)
+
+
+@box(types.UnicodeCharSeq)
+def box_unicodecharseq(typ, val, c):
+ # XXX could kind be determined from strptr?
+ unicode_kind = {
+ 1: c.pyapi.py_unicode_1byte_kind,
+ 2: c.pyapi.py_unicode_2byte_kind,
+ 4: c.pyapi.py_unicode_4byte_kind}[numpy_support.sizeof_unicode_char]
+ kind = c.context.get_constant(types.int32, unicode_kind)
+ rawptr = cgutils.alloca_once_value(c.builder, value=val)
+ strptr = c.builder.bitcast(rawptr, c.pyapi.cstring)
+
+ fullsize = c.context.get_constant(types.intp, typ.count)
+ zero = fullsize.type(0)
+ one = fullsize.type(1)
+ step = fullsize.type(numpy_support.sizeof_unicode_char)
+ count = cgutils.alloca_once_value(c.builder, zero)
+ with cgutils.loop_nest(c.builder, [fullsize], fullsize.type) as [idx]:
+ # Get char at idx
+ ch = c.builder.load(c.builder.gep(strptr, [c.builder.mul(idx, step)]))
+ # If the char is a non-null-byte, store the next index as count
+ with c.builder.if_then(cgutils.is_not_null(c.builder, ch)):
+ c.builder.store(c.builder.add(idx, one), count)
+ strlen = c.builder.load(count)
+ return c.pyapi.string_from_kind_and_data(kind, strptr, strlen)
+
+
+@unbox(types.UnicodeCharSeq)
+def unbox_unicodecharseq(typ, obj, c):
+ lty = c.context.get_value_type(typ)
+
+ ok, buffer, size, kind, is_ascii, hashv = \
+ c.pyapi.string_as_string_size_and_kind(obj)
+
+ # If conversion is ok, copy the buffer to the output storage.
+ with cgutils.if_likely(c.builder, ok):
+ # Check if the returned string size fits in the charseq
+ storage_size = ir.Constant(size.type, typ.count)
+ size_fits = c.builder.icmp_unsigned("<=", size, storage_size)
+
+ # Allow truncation of string
+ size = c.builder.select(size_fits, size, storage_size)
+
+ # Initialize output to zero bytes
+ null_string = ir.Constant(lty, None)
+ outspace = cgutils.alloca_once_value(c.builder, null_string)
+
+ # We don't need to set the NULL-terminator because the storage
+ # is already zero-filled.
+ cgutils.memcpy(c.builder,
+ c.builder.bitcast(outspace, buffer.type),
+ buffer, size)
+
+ ret = c.builder.load(outspace)
+ return NativeValue(ret, is_error=c.builder.not_(ok))
+
+
+@box(types.Bytes)
+def box_bytes(typ, val, c):
+ obj = c.context.make_helper(c.builder, typ, val)
+ ret = c.pyapi.bytes_from_string_and_size(obj.data, obj.nitems)
+ c.context.nrt.decref(c.builder, typ, val)
+ return ret
+
+
+@box(types.CharSeq)
+def box_charseq(typ, val, c):
+ rawptr = cgutils.alloca_once_value(c.builder, value=val)
+ strptr = c.builder.bitcast(rawptr, c.pyapi.cstring)
+ fullsize = c.context.get_constant(types.intp, typ.count)
+ zero = fullsize.type(0)
+ one = fullsize.type(1)
+ count = cgutils.alloca_once_value(c.builder, zero)
+
+ # Find the length of the string, mimicking Numpy's behaviour:
+ # search for the last non-null byte in the underlying storage
+ # (e.g. b'A\0\0B\0\0\0' will return the logical string b'A\0\0B')
+ with cgutils.loop_nest(c.builder, [fullsize], fullsize.type) as [idx]:
+ # Get char at idx
+ ch = c.builder.load(c.builder.gep(strptr, [idx]))
+ # If the char is a non-null-byte, store the next index as count
+ with c.builder.if_then(cgutils.is_not_null(c.builder, ch)):
+ c.builder.store(c.builder.add(idx, one), count)
+
+ strlen = c.builder.load(count)
+ return c.pyapi.bytes_from_string_and_size(strptr, strlen)
+
+
+@unbox(types.CharSeq)
+def unbox_charseq(typ, obj, c):
+ lty = c.context.get_value_type(typ)
+ ok, buffer, size = c.pyapi.string_as_string_and_size(obj)
+
+ # If conversion is ok, copy the buffer to the output storage.
+ with cgutils.if_likely(c.builder, ok):
+ # Check if the returned string size fits in the charseq
+ storage_size = ir.Constant(size.type, typ.count)
+ size_fits = c.builder.icmp_unsigned("<=", size, storage_size)
+
+ # Allow truncation of string
+ size = c.builder.select(size_fits, size, storage_size)
+
+ # Initialize output to zero bytes
+ null_string = ir.Constant(lty, None)
+ outspace = cgutils.alloca_once_value(c.builder, null_string)
+
+ # We don't need to set the NULL-terminator because the storage
+ # is already zero-filled.
+ cgutils.memcpy(c.builder,
+ c.builder.bitcast(outspace, buffer.type),
+ buffer, size)
+
+ ret = c.builder.load(outspace)
+ return NativeValue(ret, is_error=c.builder.not_(ok))
+
+
+@box(types.Optional)
+def box_optional(typ, val, c):
+ optval = c.context.make_helper(c.builder, typ, val)
+ ret = cgutils.alloca_once_value(c.builder, c.pyapi.borrow_none())
+ with c.builder.if_else(optval.valid) as (then, otherwise):
+ with then:
+ validres = c.box(typ.type, optval.data)
+ c.builder.store(validres, ret)
+ with otherwise:
+ c.builder.store(c.pyapi.make_none(), ret)
+ return c.builder.load(ret)
+
+
+@unbox(types.Optional)
+def unbox_optional(typ, obj, c):
+ """
+ Convert object *obj* to a native optional structure.
+ """
+ noneval = c.context.make_optional_none(c.builder, typ.type)
+ is_not_none = c.builder.icmp_signed('!=', obj, c.pyapi.borrow_none())
+
+ retptr = cgutils.alloca_once(c.builder, noneval.type)
+ errptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+
+ with c.builder.if_else(is_not_none) as (then, orelse):
+ with then:
+ native = c.unbox(typ.type, obj)
+ just = c.context.make_optional_value(c.builder,
+ typ.type, native.value)
+ c.builder.store(just, retptr)
+ c.builder.store(native.is_error, errptr)
+
+ with orelse:
+ c.builder.store(noneval, retptr)
+
+ if native.cleanup is not None:
+ def cleanup():
+ with c.builder.if_then(is_not_none):
+ native.cleanup()
+ else:
+ cleanup = None
+
+ ret = c.builder.load(retptr)
+ return NativeValue(ret, is_error=c.builder.load(errptr),
+ cleanup=cleanup)
+
+
+@unbox(types.SliceType)
+def unbox_slice(typ, obj, c):
+ """
+ Convert object *obj* to a native slice structure.
+ """
+ from numba.cpython import slicing
+ ok, start, stop, step = c.pyapi.slice_as_ints(obj)
+ sli = c.context.make_helper(c.builder, typ)
+ sli.start = start
+ sli.stop = stop
+ sli.step = step
+ return NativeValue(sli._getvalue(), is_error=c.builder.not_(ok))
+
+@box(types.SliceLiteral)
+def box_slice_literal(typ, val, c):
+ # Check for integer overflows at compile time.
+ slice_lit = typ.literal_value
+ for field_name in ("start", "stop", "step"):
+ field_obj = getattr(slice_lit, field_name)
+ if isinstance(field_obj, int):
+ try:
+ typeof(field_obj, Purpose)
+ except ValueError as e:
+ raise ValueError((
+ f"Unable to create literal slice. "
+ f"Error encountered with {field_name} "
+ f"attribute. {str(e)}")
+ )
+
+ py_ctor, py_args = typ.literal_value.__reduce__()
+ serialized_ctor = c.pyapi.serialize_object(py_ctor)
+ serialized_args = c.pyapi.serialize_object(py_args)
+ ctor = c.pyapi.unserialize(serialized_ctor)
+ args = c.pyapi.unserialize(serialized_args)
+ obj = c.pyapi.call(ctor, args)
+ c.pyapi.decref(ctor)
+ c.pyapi.decref(args)
+ return obj
+
+@unbox(types.StringLiteral)
+def unbox_string_literal(typ, obj, c):
+ # A string literal is a dummy value
+ return NativeValue(c.context.get_dummy_value())
+
+#
+# Collections
+#
+
+# NOTE: boxing functions are supposed to steal any NRT references in
+# the given native value.
+
+@box(types.Array)
+def box_array(typ, val, c):
+ nativearycls = c.context.make_array(typ)
+ nativeary = nativearycls(c.context, c.builder, value=val)
+ if c.context.enable_nrt:
+ np_dtype = numpy_support.as_dtype(typ.dtype)
+ dtypeptr = c.env_manager.read_const(c.env_manager.add_const(np_dtype))
+ newary = c.pyapi.nrt_adapt_ndarray_to_python(typ, val, dtypeptr)
+ # Steals NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return newary
+ else:
+ parent = nativeary.parent
+ c.pyapi.incref(parent)
+ return parent
+
+
+@unbox(types.Buffer)
+def unbox_buffer(typ, obj, c):
+ """
+ Convert a Py_buffer-providing object to a native array structure.
+ """
+ buf = c.pyapi.alloca_buffer()
+ res = c.pyapi.get_buffer(obj, buf)
+ is_error = cgutils.is_not_null(c.builder, res)
+
+ nativearycls = c.context.make_array(typ)
+ nativeary = nativearycls(c.context, c.builder)
+ aryptr = nativeary._getpointer()
+
+ with cgutils.if_likely(c.builder, c.builder.not_(is_error)):
+ ptr = c.builder.bitcast(aryptr, c.pyapi.voidptr)
+ if c.context.enable_nrt:
+ c.pyapi.nrt_adapt_buffer_from_python(buf, ptr)
+ else:
+ c.pyapi.numba_buffer_adaptor(buf, ptr)
+
+ def cleanup():
+ c.pyapi.release_buffer(buf)
+
+ return NativeValue(c.builder.load(aryptr), is_error=is_error,
+ cleanup=cleanup)
+
+@unbox(types.Array)
+def unbox_array(typ, obj, c):
+ """
+ Convert a Numpy array object to a native array structure.
+ """
+ # This is necessary because unbox_buffer() does not work on some
+ # dtypes, e.g. datetime64 and timedelta64.
+ # TODO check matching dtype.
+ # currently, mismatching dtype will still work and causes
+ # potential memory corruption
+ nativearycls = c.context.make_array(typ)
+ nativeary = nativearycls(c.context, c.builder)
+ aryptr = nativeary._getpointer()
+
+ ptr = c.builder.bitcast(aryptr, c.pyapi.voidptr)
+ if c.context.enable_nrt:
+ errcode = c.pyapi.nrt_adapt_ndarray_from_python(obj, ptr)
+ else:
+ errcode = c.pyapi.numba_array_adaptor(obj, ptr)
+
+ # TODO: here we have minimal typechecking by the itemsize.
+ # need to do better
+ try:
+ expected_itemsize = numpy_support.as_dtype(typ.dtype).itemsize
+ except NumbaNotImplementedError:
+ # Don't check types that can't be `as_dtype()`-ed
+ itemsize_mismatch = cgutils.false_bit
+ else:
+ expected_itemsize = nativeary.itemsize.type(expected_itemsize)
+ itemsize_mismatch = c.builder.icmp_unsigned(
+ '!=',
+ nativeary.itemsize,
+ expected_itemsize,
+ )
+
+ failed = c.builder.or_(
+ cgutils.is_not_null(c.builder, errcode),
+ itemsize_mismatch,
+ )
+ # Handle error
+ with c.builder.if_then(failed, likely=False):
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "can't unbox array from PyObject into "
+ "native value. The object maybe of a "
+ "different type")
+ return NativeValue(c.builder.load(aryptr), is_error=failed)
+
+
+@box(types.Tuple)
+@box(types.UniTuple)
+def box_tuple(typ, val, c):
+ """
+ Convert native array or structure *val* to a tuple object.
+ """
+ tuple_val = c.pyapi.tuple_new(typ.count)
+
+ for i, dtype in enumerate(typ):
+ item = c.builder.extract_value(val, i)
+ obj = c.box(dtype, item)
+ c.pyapi.tuple_setitem(tuple_val, i, obj)
+
+ return tuple_val
+
+@box(types.NamedTuple)
+@box(types.NamedUniTuple)
+def box_namedtuple(typ, val, c):
+ """
+ Convert native array or structure *val* to a namedtuple object.
+ """
+ cls_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ.instance_class))
+ tuple_obj = box_tuple(typ, val, c)
+ obj = c.pyapi.call(cls_obj, tuple_obj)
+ c.pyapi.decref(cls_obj)
+ c.pyapi.decref(tuple_obj)
+ return obj
+
+
+@unbox(types.BaseTuple)
+def unbox_tuple(typ, obj, c):
+ """
+ Convert tuple *obj* to a native array (if homogeneous) or structure.
+ """
+ n = len(typ)
+ values = []
+ cleanups = []
+ lty = c.context.get_value_type(typ)
+
+ is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ value_ptr = cgutils.alloca_once(c.builder, lty)
+
+ # Issue #1638: need to check the tuple size
+ actual_size = c.pyapi.tuple_size(obj)
+ size_matches = c.builder.icmp_unsigned('==', actual_size,
+ ir.Constant(actual_size.type, n))
+ with c.builder.if_then(c.builder.not_(size_matches), likely=False):
+ c.pyapi.err_format(
+ "PyExc_ValueError",
+ "size mismatch for tuple, expected %d element(s) but got %%zd" % (n,),
+ actual_size)
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+
+ # We unbox the items even if not `size_matches`, to avoid issues with
+ # the generated IR (instruction doesn't dominate all uses)
+ for i, eltype in enumerate(typ):
+ elem = c.pyapi.tuple_getitem(obj, i)
+ native = c.unbox(eltype, elem)
+ values.append(native.value)
+ with c.builder.if_then(native.is_error, likely=False):
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+ if native.cleanup is not None:
+ cleanups.append(native.cleanup)
+
+ value = c.context.make_tuple(c.builder, typ, values)
+ c.builder.store(value, value_ptr)
+
+ if cleanups:
+ with c.builder.if_then(size_matches, likely=True):
+ def cleanup():
+ for func in reversed(cleanups):
+ func()
+ else:
+ cleanup = None
+
+ return NativeValue(c.builder.load(value_ptr), cleanup=cleanup,
+ is_error=c.builder.load(is_error_ptr))
+
+
+@box(types.List)
+def box_list(typ, val, c):
+ """
+ Convert native list *val* to a list object.
+ """
+ list = listobj.ListInstance(c.context, c.builder, typ, val)
+ obj = list.parent
+ res = cgutils.alloca_once_value(c.builder, obj)
+ with c.builder.if_else(cgutils.is_not_null(c.builder, obj)) as (has_parent, otherwise):
+ with has_parent:
+ # List is actually reflected => return the original object
+ # (note not all list instances whose *type* is reflected are
+ # actually reflected; see numba.tests.test_lists for an example)
+ c.pyapi.incref(obj)
+
+ with otherwise:
+ # Build a new Python list
+ nitems = list.size
+ obj = c.pyapi.list_new(nitems)
+ with c.builder.if_then(cgutils.is_not_null(c.builder, obj),
+ likely=True):
+ with cgutils.for_range(c.builder, nitems) as loop:
+ item = list.getitem(loop.index)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(obj, loop.index, itemobj)
+
+ c.builder.store(obj, res)
+
+ # Steal NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return c.builder.load(res)
+
+
+class _NumbaTypeHelper(object):
+ """A helper for acquiring `numba.typeof` for type checking.
+
+ Usage
+ -----
+
+ # `c` is the boxing context.
+ with _NumbaTypeHelper(c) as nth:
+ # This contextmanager maintains the lifetime of the `numba.typeof`
+ # function.
+ the_numba_type = nth.typeof(some_object)
+ # Do work on the type object
+ do_checks(the_numba_type)
+ # Cleanup
+ c.pyapi.decref(the_numba_type)
+ # At this point *nth* should not be used.
+ """
+ def __init__(self, c):
+ self.c = c
+
+ def __enter__(self):
+ c = self.c
+ numba_name = c.context.insert_const_string(c.builder.module, 'numba')
+ numba_mod = c.pyapi.import_module(numba_name)
+ typeof_fn = c.pyapi.object_getattr_string(numba_mod, 'typeof')
+ self.typeof_fn = typeof_fn
+ c.pyapi.decref(numba_mod)
+ return self
+
+ def __exit__(self, *args, **kwargs):
+ c = self.c
+ c.pyapi.decref(self.typeof_fn)
+
+ def typeof(self, obj):
+ res = self.c.pyapi.call_function_objargs(self.typeof_fn, [obj])
+ return res
+
+
+def _python_list_to_native(typ, obj, c, size, listptr, errorptr):
+ """
+ Construct a new native list from a Python list.
+ """
+ def check_element_type(nth, itemobj, expected_typobj):
+ typobj = nth.typeof(itemobj)
+ # Check if *typobj* is NULL
+ with c.builder.if_then(
+ cgutils.is_null(c.builder, typobj),
+ likely=False,
+ ):
+ c.builder.store(cgutils.true_bit, errorptr)
+ loop.do_break()
+ # Mandate that objects all have the same exact type
+ type_mismatch = c.builder.icmp_signed('!=', typobj, expected_typobj)
+
+ with c.builder.if_then(type_mismatch, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ c.pyapi.err_format(
+ "PyExc_TypeError",
+ "can't unbox heterogeneous list: %S != %S",
+ expected_typobj, typobj,
+ )
+ c.pyapi.decref(typobj)
+ loop.do_break()
+ c.pyapi.decref(typobj)
+
+ # Allocate a new native list
+ ok, list = listobj.ListInstance.allocate_ex(c.context, c.builder, typ, size)
+ with c.builder.if_else(ok, likely=True) as (if_ok, if_not_ok):
+ with if_ok:
+ list.size = size
+ zero = ir.Constant(size.type, 0)
+ with c.builder.if_then(c.builder.icmp_signed('>', size, zero),
+ likely=True):
+ # Traverse Python list and unbox objects into native list
+ with _NumbaTypeHelper(c) as nth:
+ # Note: *expected_typobj* can't be NULL
+ expected_typobj = nth.typeof(c.pyapi.list_getitem(obj, zero))
+ with cgutils.for_range(c.builder, size) as loop:
+ itemobj = c.pyapi.list_getitem(obj, loop.index)
+ check_element_type(nth, itemobj, expected_typobj)
+ # XXX we don't call native cleanup for each
+ # list element, since that would require keeping
+ # of which unboxings have been successful.
+ native = c.unbox(typ.dtype, itemobj)
+ with c.builder.if_then(native.is_error, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ loop.do_break()
+ # The reference is borrowed so incref=False
+ list.setitem(loop.index, native.value, incref=False)
+ c.pyapi.decref(expected_typobj)
+ if typ.reflected:
+ list.parent = obj
+ # Stuff meminfo pointer into the Python object for
+ # later reuse.
+ with c.builder.if_then(c.builder.not_(c.builder.load(errorptr)),
+ likely=False):
+ c.pyapi.object_set_private_data(obj, list.meminfo)
+ list.set_dirty(False)
+ c.builder.store(list.value, listptr)
+
+ with if_not_ok:
+ c.builder.store(cgutils.true_bit, errorptr)
+
+ # If an error occurred, drop the whole native list
+ with c.builder.if_then(c.builder.load(errorptr)):
+ c.context.nrt.decref(c.builder, typ, list.value)
+
+
+@unbox(types.List)
+def unbox_list(typ, obj, c):
+ """
+ Convert list *obj* to a native list.
+
+ If list was previously unboxed, we reuse the existing native list
+ to ensure consistency.
+ """
+ size = c.pyapi.list_size(obj)
+
+ errorptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ listptr = cgutils.alloca_once(c.builder, c.context.get_value_type(typ))
+
+ # See if the list was previously unboxed, if so, re-use the meminfo.
+ ptr = c.pyapi.object_get_private_data(obj)
+
+ with c.builder.if_else(cgutils.is_not_null(c.builder, ptr)) \
+ as (has_meminfo, otherwise):
+
+ with has_meminfo:
+ # List was previously unboxed => reuse meminfo
+ list = listobj.ListInstance.from_meminfo(c.context, c.builder, typ, ptr)
+ list.size = size
+ if typ.reflected:
+ list.parent = obj
+ c.builder.store(list.value, listptr)
+
+ with otherwise:
+ _python_list_to_native(typ, obj, c, size, listptr, errorptr)
+
+ def cleanup():
+ # Clean up the associated pointer, as the meminfo is now invalid.
+ c.pyapi.object_reset_private_data(obj)
+
+ return NativeValue(c.builder.load(listptr),
+ is_error=c.builder.load(errorptr),
+ cleanup=cleanup)
+
+
+@reflect(types.List)
+def reflect_list(typ, val, c):
+ """
+ Reflect the native list's contents into the Python object.
+ """
+ if not typ.reflected:
+ return
+ if typ.dtype.reflected:
+ msg = "cannot reflect element of reflected container: {}\n".format(typ)
+ raise TypeError(msg)
+
+ list = listobj.ListInstance(c.context, c.builder, typ, val)
+ with c.builder.if_then(list.dirty, likely=False):
+ obj = list.parent
+ size = c.pyapi.list_size(obj)
+ new_size = list.size
+ diff = c.builder.sub(new_size, size)
+ diff_gt_0 = c.builder.icmp_signed('>=', diff,
+ ir.Constant(diff.type, 0))
+ with c.builder.if_else(diff_gt_0) as (if_grow, if_shrink):
+ # XXX no error checking below
+ with if_grow:
+ # First overwrite existing items
+ with cgutils.for_range(c.builder, size) as loop:
+ item = list.getitem(loop.index)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(obj, loop.index, itemobj)
+ # Then add missing items
+ with cgutils.for_range(c.builder, diff) as loop:
+ idx = c.builder.add(size, loop.index)
+ item = list.getitem(idx)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_append(obj, itemobj)
+ c.pyapi.decref(itemobj)
+
+ with if_shrink:
+ # First delete list tail
+ c.pyapi.list_setslice(obj, new_size, size, None)
+ # Then overwrite remaining items
+ with cgutils.for_range(c.builder, new_size) as loop:
+ item = list.getitem(loop.index)
+ list.incref_value(item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(obj, loop.index, itemobj)
+
+ # Mark the list clean, in case it is reflected twice
+ list.set_dirty(False)
+
+
+def _python_set_to_native(typ, obj, c, size, setptr, errorptr):
+ """
+ Construct a new native set from a Python set.
+ """
+ # Allocate a new native set
+ ok, inst = setobj.SetInstance.allocate_ex(c.context, c.builder, typ, size)
+ with c.builder.if_else(ok, likely=True) as (if_ok, if_not_ok):
+ with if_ok:
+ # Traverse Python set and unbox objects into native set
+ typobjptr = cgutils.alloca_once_value(c.builder,
+ ir.Constant(c.pyapi.pyobj, None))
+
+ with c.pyapi.set_iterate(obj) as loop:
+ itemobj = loop.value
+ # Mandate that objects all have the same exact type
+ typobj = c.pyapi.get_type(itemobj)
+ expected_typobj = c.builder.load(typobjptr)
+
+ with c.builder.if_else(
+ cgutils.is_null(c.builder, expected_typobj),
+ likely=False) as (if_first, if_not_first):
+ with if_first:
+ # First iteration => store item type
+ c.builder.store(typobj, typobjptr)
+ with if_not_first:
+ # Otherwise, check item type
+ type_mismatch = c.builder.icmp_signed('!=', typobj,
+ expected_typobj)
+ with c.builder.if_then(type_mismatch, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "can't unbox heterogeneous set")
+ loop.do_break()
+
+ # XXX we don't call native cleanup for each set element,
+ # since that would require keeping track
+ # of which unboxings have been successful.
+ native = c.unbox(typ.dtype, itemobj)
+ with c.builder.if_then(native.is_error, likely=False):
+ c.builder.store(cgutils.true_bit, errorptr)
+ inst.add_pyapi(c.pyapi, native.value, do_resize=False)
+
+ if typ.reflected:
+ inst.parent = obj
+ # Associate meminfo pointer with the Python object for later reuse.
+ with c.builder.if_then(c.builder.not_(c.builder.load(errorptr)),
+ likely=False):
+ c.pyapi.object_set_private_data(obj, inst.meminfo)
+ inst.set_dirty(False)
+ c.builder.store(inst.value, setptr)
+
+ with if_not_ok:
+ c.builder.store(cgutils.true_bit, errorptr)
+
+ # If an error occurred, drop the whole native set
+ with c.builder.if_then(c.builder.load(errorptr)):
+ c.context.nrt.decref(c.builder, typ, inst.value)
+
+
+@unbox(types.Set)
+def unbox_set(typ, obj, c):
+ """
+ Convert set *obj* to a native set.
+
+ If set was previously unboxed, we reuse the existing native set
+ to ensure consistency.
+ """
+ size = c.pyapi.set_size(obj)
+
+ errorptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ setptr = cgutils.alloca_once(c.builder, c.context.get_value_type(typ))
+
+ # See if the set was previously unboxed, if so, re-use the meminfo.
+ ptr = c.pyapi.object_get_private_data(obj)
+
+ with c.builder.if_else(cgutils.is_not_null(c.builder, ptr)) \
+ as (has_meminfo, otherwise):
+
+ with has_meminfo:
+ # Set was previously unboxed => reuse meminfo
+ inst = setobj.SetInstance.from_meminfo(c.context, c.builder, typ, ptr)
+ if typ.reflected:
+ inst.parent = obj
+ c.builder.store(inst.value, setptr)
+
+ with otherwise:
+ _python_set_to_native(typ, obj, c, size, setptr, errorptr)
+
+ def cleanup():
+ # Clean up the associated pointer, as the meminfo is now invalid.
+ c.pyapi.object_reset_private_data(obj)
+
+ return NativeValue(c.builder.load(setptr),
+ is_error=c.builder.load(errorptr),
+ cleanup=cleanup)
+
+
+def _native_set_to_python_list(typ, payload, c):
+ """
+ Create a Python list from a native set's items.
+ """
+ nitems = payload.used
+ listobj = c.pyapi.list_new(nitems)
+ ok = cgutils.is_not_null(c.builder, listobj)
+ with c.builder.if_then(ok, likely=True):
+ index = cgutils.alloca_once_value(c.builder,
+ ir.Constant(nitems.type, 0))
+ with payload._iterate() as loop:
+ i = c.builder.load(index)
+ item = loop.entry.key
+ c.context.nrt.incref(c.builder, typ.dtype, item)
+ itemobj = c.box(typ.dtype, item)
+ c.pyapi.list_setitem(listobj, i, itemobj)
+ i = c.builder.add(i, ir.Constant(i.type, 1))
+ c.builder.store(i, index)
+
+ return ok, listobj
+
+
+@box(types.Set)
+def box_set(typ, val, c):
+ """
+ Convert native set *val* to a set object.
+ """
+ inst = setobj.SetInstance(c.context, c.builder, typ, val)
+ obj = inst.parent
+ res = cgutils.alloca_once_value(c.builder, obj)
+
+ with c.builder.if_else(cgutils.is_not_null(c.builder, obj)) as (has_parent, otherwise):
+ with has_parent:
+ # Set is actually reflected => return the original object
+ # (note not all set instances whose *type* is reflected are
+ # actually reflected; see numba.tests.test_sets for an example)
+ c.pyapi.incref(obj)
+
+ with otherwise:
+ # Build a new Python list and then create a set from that
+ payload = inst.payload
+ ok, listobj = _native_set_to_python_list(typ, payload, c)
+ with c.builder.if_then(ok, likely=True):
+ obj = c.pyapi.set_new(listobj)
+ c.pyapi.decref(listobj)
+ c.builder.store(obj, res)
+
+ # Steal NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return c.builder.load(res)
+
+@reflect(types.Set)
+def reflect_set(typ, val, c):
+ """
+ Reflect the native set's contents into the Python object.
+ """
+ if not typ.reflected:
+ return
+ inst = setobj.SetInstance(c.context, c.builder, typ, val)
+ payload = inst.payload
+
+ with c.builder.if_then(payload.dirty, likely=False):
+ obj = inst.parent
+ # XXX errors are not dealt with below
+ c.pyapi.set_clear(obj)
+
+ # Build a new Python list and then update the set with that
+ ok, listobj = _native_set_to_python_list(typ, payload, c)
+ with c.builder.if_then(ok, likely=True):
+ c.pyapi.set_update(obj, listobj)
+ c.pyapi.decref(listobj)
+
+ # Mark the set clean, in case it is reflected twice
+ inst.set_dirty(False)
+
+
+#
+# Other types
+#
+
+@box(types.Generator)
+def box_generator(typ, val, c):
+ return c.pyapi.from_native_generator(val, typ, c.env_manager.env_ptr)
+
+@unbox(types.Generator)
+def unbox_generator(typ, obj, c):
+ return c.pyapi.to_native_generator(obj, typ)
+
+
+@box(types.DType)
+def box_dtype(typ, val, c):
+ np_dtype = numpy_support.as_dtype(typ.dtype)
+ return c.pyapi.unserialize(c.pyapi.serialize_object(np_dtype))
+
+@unbox(types.DType)
+def unbox_dtype(typ, val, c):
+ return NativeValue(c.context.get_dummy_value())
+
+
+@box(types.NumberClass)
+def box_number_class(typ, val, c):
+ np_dtype = numpy_support.as_dtype(typ.dtype)
+ return c.pyapi.unserialize(c.pyapi.serialize_object(np_dtype))
+
+@unbox(types.NumberClass)
+def unbox_number_class(typ, val, c):
+ return NativeValue(c.context.get_dummy_value())
+
+
+@box(types.PyObject)
+@box(types.Object)
+def box_pyobject(typ, val, c):
+ return val
+
+@unbox(types.PyObject)
+@unbox(types.Object)
+def unbox_pyobject(typ, obj, c):
+ return NativeValue(obj)
+
+
+@unbox(types.ExternalFunctionPointer)
+def unbox_funcptr(typ, obj, c):
+ if typ.get_pointer is None:
+ raise NotImplementedError(typ)
+
+ # Call get_pointer() on the object to get the raw pointer value
+ ptrty = c.context.get_function_pointer_type(typ)
+ ret = cgutils.alloca_once_value(c.builder,
+ ir.Constant(ptrty, None),
+ name='fnptr')
+ ser = c.pyapi.serialize_object(typ.get_pointer)
+ get_pointer = c.pyapi.unserialize(ser)
+ with cgutils.if_likely(c.builder,
+ cgutils.is_not_null(c.builder, get_pointer)):
+ intobj = c.pyapi.call_function_objargs(get_pointer, (obj,))
+ c.pyapi.decref(get_pointer)
+ with cgutils.if_likely(c.builder,
+ cgutils.is_not_null(c.builder, intobj)):
+ ptr = c.pyapi.long_as_voidptr(intobj)
+ c.pyapi.decref(intobj)
+ c.builder.store(c.builder.bitcast(ptr, ptrty), ret)
+ return NativeValue(c.builder.load(ret), is_error=c.pyapi.c_api_error())
+
+@box(types.DeferredType)
+def box_deferred(typ, val, c):
+ out = c.pyapi.from_native_value(typ.get(),
+ c.builder.extract_value(val, [0]),
+ env_manager=c.env_manager)
+ return out
+
+
+@unbox(types.DeferredType)
+def unbox_deferred(typ, obj, c):
+ native_value = c.pyapi.to_native_value(typ.get(), obj)
+ model = c.context.data_model_manager[typ]
+ res = model.set(c.builder, model.make_uninitialized(), native_value.value)
+ return NativeValue(res, is_error=native_value.is_error,
+ cleanup=native_value.cleanup)
+
+
+@unbox(types.Dispatcher)
+def unbox_dispatcher(typ, obj, c):
+ # In native code, Dispatcher types can be casted to FunctionType.
+ return NativeValue(obj)
+
+
+@box(types.Dispatcher)
+def box_pyobject(typ, val, c):
+ c.pyapi.incref(val)
+ return val
+
+
+def unbox_unsupported(typ, obj, c):
+ c.pyapi.err_set_string("PyExc_TypeError",
+ "can't unbox {!r} type".format(typ))
+ res = c.context.get_constant_null(typ)
+ return NativeValue(res, is_error=cgutils.true_bit)
+
+
+def box_unsupported(typ, val, c):
+ msg = "cannot convert native %s to Python object" % (typ,)
+ c.pyapi.err_set_string("PyExc_TypeError", msg)
+ res = c.pyapi.get_null_object()
+ return res
+
+
+@box(types.Literal)
+def box_literal(typ, val, c):
+ # Const type contains the python object of the constant value,
+ # which we can directly return.
+ retval = typ.literal_value
+ # Serialize the value into the IR
+ return c.pyapi.unserialize(c.pyapi.serialize_object(retval))
+
+
+@box(types.MemInfoPointer)
+def box_meminfo_pointer(typ, val, c):
+ return c.pyapi.nrt_meminfo_as_pyobject(val)
+
+
+@unbox(types.MemInfoPointer)
+def unbox_meminfo_pointer(typ, obj, c):
+ res = c.pyapi.nrt_meminfo_from_pyobject(obj)
+ errored = cgutils.is_null(c.builder, res)
+ return NativeValue(res, is_error=errored)
+
+@unbox(types.TypeRef)
+def unbox_typeref(typ, val, c):
+ return NativeValue(c.context.get_dummy_value(), is_error=cgutils.false_bit)
+
+
+@box(types.LiteralStrKeyDict)
+def box_LiteralStrKeyDict(typ, val, c):
+ return box_unsupported(typ, val, c)
+
+
+# Original implementation at: https://github.com/numba/numba/issues/4499#issuecomment-1063138477
+@unbox(types.NumPyRandomBitGeneratorType)
+def unbox_numpy_random_bitgenerator(typ, obj, c):
+ """
+ The bit_generator instance has a `.ctypes` attr which is a namedtuple
+ with the following members (types):
+ * state_address (Python int)
+ * state (ctypes.c_void_p)
+ * next_uint64 (ctypes.CFunctionType instance)
+ * next_uint32 (ctypes.CFunctionType instance)
+ * next_double (ctypes.CFunctionType instance)
+ * bit_generator (ctypes.c_void_p)
+ """
+
+ is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+ extra_refs = []
+
+ def clear_extra_refs():
+ for _ref in extra_refs:
+ c.pyapi.decref(_ref)
+
+ def handle_failure():
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+ clear_extra_refs()
+
+ with ExitStack() as stack:
+
+ def object_getattr_safely(obj, attr):
+ attr_obj = c.pyapi.object_getattr_string(obj, attr)
+ extra_refs.append(attr_obj)
+ return attr_obj
+
+ struct_ptr = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+ struct_ptr.parent = obj
+
+ # Get the .ctypes attr
+ ctypes_binding = object_getattr_safely(obj, 'ctypes')
+ with cgutils.early_exit_if_null(c.builder, stack, ctypes_binding):
+ handle_failure()
+
+ # Look up the "state_address" member and wire it into the struct
+ interface_state_address = object_getattr_safely(
+ ctypes_binding, 'state_address')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_state_address):
+ handle_failure()
+
+ setattr(struct_ptr, 'state_address',
+ c.unbox(types.uintp, interface_state_address).value)
+
+ # Look up the "state" member and wire it into the struct
+ interface_state = object_getattr_safely(ctypes_binding, 'state')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_state):
+ handle_failure()
+
+ interface_state_value = object_getattr_safely(
+ interface_state, 'value')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_state_value):
+ handle_failure()
+ setattr(
+ struct_ptr,
+ 'state',
+ c.unbox(
+ types.uintp,
+ interface_state_value).value)
+
+ # Want to store callable function pointers to these CFunctionTypes, so
+ # import ctypes and use it to cast the CFunctionTypes to c_void_p and
+ # store the results.
+ # First find ctypes.cast, and ctypes.c_void_p
+ ctypes_name = c.context.insert_const_string(c.builder.module, 'ctypes')
+ ctypes_module = c.pyapi.import_module(ctypes_name)
+ extra_refs.append(ctypes_module)
+ with cgutils.early_exit_if_null(c.builder, stack, ctypes_module):
+ handle_failure()
+
+ ct_cast = object_getattr_safely(ctypes_module, 'cast')
+ with cgutils.early_exit_if_null(c.builder, stack, ct_cast):
+ handle_failure()
+
+ ct_voidptr_ty = object_getattr_safely(ctypes_module, 'c_void_p')
+ with cgutils.early_exit_if_null(c.builder, stack, ct_voidptr_ty):
+ handle_failure()
+
+ # This wires in the fnptrs referred to by name
+ def wire_in_fnptrs(name):
+ # Find the CFunctionType function
+ interface_next_fn = c.pyapi.object_getattr_string(
+ ctypes_binding, name)
+
+ extra_refs.append(interface_next_fn)
+ with cgutils.early_exit_if_null(c.builder, stack, interface_next_fn):
+ handle_failure()
+
+ # Want to do ctypes.cast(CFunctionType, ctypes.c_void_p), create an
+ # args tuple for that.
+ args = c.pyapi.tuple_pack([interface_next_fn, ct_voidptr_ty])
+ with cgutils.early_exit_if_null(c.builder, stack, args):
+ handle_failure()
+ extra_refs.append(args)
+
+ # Call ctypes.cast()
+ interface_next_fn_casted = c.pyapi.call(ct_cast, args)
+ extra_refs.append(interface_next_fn_casted)
+
+ # Fetch the .value attr on the resulting ctypes.c_void_p for storage
+ # in the function pointer slot.
+ interface_next_fn_casted_value = object_getattr_safely(
+ interface_next_fn_casted, 'value')
+ with cgutils.early_exit_if_null(c.builder, stack, interface_next_fn_casted_value):
+ handle_failure()
+
+ # Wire up
+ setattr(struct_ptr, f'fnptr_{name}',
+ c.unbox(types.uintp, interface_next_fn_casted_value).value)
+
+
+ wire_in_fnptrs('next_double')
+ wire_in_fnptrs('next_uint64')
+ wire_in_fnptrs('next_uint32')
+
+ clear_extra_refs()
+
+ return NativeValue(struct_ptr._getvalue(), is_error=c.builder.load(is_error_ptr))
+
+_bit_gen_type = types.NumPyRandomBitGeneratorType('bit_generator')
+
+@unbox(types.NumPyRandomGeneratorType)
+def unbox_numpy_random_generator(typ, obj, c):
+ """
+ Here we're creating a NumPyRandomGeneratorType StructModel with following fields:
+ * ('bit_generator', _bit_gen_type): The unboxed BitGenerator associated with
+ this Generator object instance.
+ * ('parent', types.pyobject): Pointer to the original Generator PyObject.
+ * ('meminfo', types.MemInfoPointer(types.voidptr)): The information about the memory
+ stored at the pointer (to the original Generator PyObject). This is useful for
+ keeping track of reference counts within the Python runtime. Helps prevent cases
+ where deletion happens in Python runtime without NRT being awareness of it.
+ """
+ is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+
+ with ExitStack() as stack:
+ struct_ptr = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+ bit_gen_inst = c.pyapi.object_getattr_string(obj, 'bit_generator')
+ with cgutils.early_exit_if_null(c.builder, stack, bit_gen_inst):
+ c.builder.store(cgutils.true_bit, is_error_ptr)
+ unboxed = c.unbox(_bit_gen_type, bit_gen_inst).value
+ struct_ptr.bit_generator = unboxed
+ struct_ptr.parent = obj
+ NULL = cgutils.voidptr_t(None)
+ struct_ptr.meminfo = c.pyapi.nrt_meminfo_new_from_pyobject(
+ NULL, # there's no data
+ obj, # the python object, the call to nrt_meminfo_new_from_pyobject
+ # will py_incref
+ )
+ c.pyapi.decref(bit_gen_inst)
+
+ return NativeValue(struct_ptr._getvalue(), is_error=c.builder.load(is_error_ptr))
+
+
+@box(types.NumPyRandomGeneratorType)
+def box_numpy_random_generator(typ, val, c):
+ inst = c.context.make_helper(c.builder, typ, val)
+ obj = inst.parent
+ res = cgutils.alloca_once_value(c.builder, obj)
+ c.pyapi.incref(obj)
+ # Steal NRT ref
+ c.context.nrt.decref(c.builder, typ, val)
+ return c.builder.load(res)
diff --git a/venv/lib/python3.10/site-packages/numba/core/optional.py b/venv/lib/python3.10/site-packages/numba/core/optional.py
new file mode 100644
index 0000000000000000000000000000000000000000..16dcb52360ad2190c9b6af44023a362bbc33bf37
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/optional.py
@@ -0,0 +1,121 @@
+import operator
+
+from numba.core import types, typing, cgutils
+
+from numba.core.imputils import (lower_cast, lower_builtin,
+ lower_getattr_generic, impl_ret_untracked,
+ lower_setattr_generic)
+
+
+def always_return_true_impl(context, builder, sig, args):
+ return cgutils.true_bit
+
+
+def always_return_false_impl(context, builder, sig, args):
+ return cgutils.false_bit
+
+
+def optional_is_none(context, builder, sig, args):
+ """
+ Check if an Optional value is invalid
+ """
+ [lty, rty] = sig.args
+ [lval, rval] = args
+
+ # Make sure None is on the right
+ if lty == types.none:
+ lty, rty = rty, lty
+ lval, rval = rval, lval
+
+ opt_type = lty
+ opt_val = lval
+
+ opt = context.make_helper(builder, opt_type, opt_val)
+ res = builder.not_(cgutils.as_bool_bit(builder, opt.valid))
+ return impl_ret_untracked(context, builder, sig.return_type, res)
+
+
+# None is/not None
+lower_builtin(operator.is_, types.none, types.none)(always_return_true_impl)
+
+# Optional is None
+lower_builtin(operator.is_, types.Optional, types.none)(optional_is_none)
+lower_builtin(operator.is_, types.none, types.Optional)(optional_is_none)
+
+
+@lower_getattr_generic(types.Optional)
+def optional_getattr(context, builder, typ, value, attr):
+ """
+ Optional.__getattr__ => redirect to the wrapped type.
+ """
+ inner_type = typ.type
+ val = context.cast(builder, value, typ, inner_type)
+ imp = context.get_getattr(inner_type, attr)
+ return imp(context, builder, inner_type, val, attr)
+
+
+@lower_setattr_generic(types.Optional)
+def optional_setattr(context, builder, sig, args, attr):
+ """
+ Optional.__setattr__ => redirect to the wrapped type.
+ """
+ basety, valty = sig.args
+ target, val = args
+ target_type = basety.type
+ target = context.cast(builder, target, basety, target_type)
+
+ newsig = typing.signature(sig.return_type, target_type, valty)
+ imp = context.get_setattr(attr, newsig)
+ return imp(builder, (target, val))
+
+
+@lower_cast(types.Optional, types.Optional)
+def optional_to_optional(context, builder, fromty, toty, val):
+ """
+ The handling of optional->optional cast must be special cased for
+ correct propagation of None value. Given type T and U. casting of
+ T? to U? (? denotes optional) should always succeed. If the from-value
+ is None, the None value the casted value (U?) should be None; otherwise,
+ the from-value is casted to U. This is different from casting T? to U,
+ which requires the from-value must not be None.
+ """
+ optval = context.make_helper(builder, fromty, value=val)
+ validbit = cgutils.as_bool_bit(builder, optval.valid)
+ # Create uninitialized optional value
+ outoptval = context.make_helper(builder, toty)
+
+ with builder.if_else(validbit) as (is_valid, is_not_valid):
+ with is_valid:
+ # Cast internal value
+ outoptval.valid = cgutils.true_bit
+ outoptval.data = context.cast(builder, optval.data,
+ fromty.type, toty.type)
+
+ with is_not_valid:
+ # Store None to result
+ outoptval.valid = cgutils.false_bit
+ outoptval.data = cgutils.get_null_value(
+ outoptval.data.type)
+
+ return outoptval._getvalue()
+
+
+@lower_cast(types.Any, types.Optional)
+def any_to_optional(context, builder, fromty, toty, val):
+ if fromty == types.none:
+ return context.make_optional_none(builder, toty.type)
+ else:
+ val = context.cast(builder, val, fromty, toty.type)
+ return context.make_optional_value(builder, toty.type, val)
+
+
+@lower_cast(types.Optional, types.Any)
+@lower_cast(types.Optional, types.Boolean)
+def optional_to_any(context, builder, fromty, toty, val):
+ optval = context.make_helper(builder, fromty, value=val)
+ validbit = cgutils.as_bool_bit(builder, optval.valid)
+ with builder.if_then(builder.not_(validbit), likely=False):
+ msg = "expected %s, got None" % (fromty.type,)
+ context.call_conv.return_user_exc(builder, TypeError, (msg,))
+
+ return context.cast(builder, optval.data, fromty.type, toty)
diff --git a/venv/lib/python3.10/site-packages/numba/core/options.py b/venv/lib/python3.10/site-packages/numba/core/options.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8e99c8daad1e9cdbec479aba13bcd069e5148f9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/options.py
@@ -0,0 +1,108 @@
+"""
+Target Options
+"""
+import operator
+
+from numba.core import config, utils
+from numba.core.targetconfig import TargetConfig, Option
+
+
+class TargetOptions:
+ """Target options maps user options from decorators to the
+ ``numba.core.compiler.Flags`` used by lowering and target context.
+ """
+ class Mapping:
+ def __init__(self, flag_name, apply=lambda x: x):
+ self.flag_name = flag_name
+ self.apply = apply
+
+ def finalize(self, flags, options):
+ """Subclasses can override this method to make target specific
+ customizations of default flags.
+
+ Parameters
+ ----------
+ flags : Flags
+ options : dict
+ """
+ pass
+
+ @classmethod
+ def parse_as_flags(cls, flags, options):
+ """Parse target options defined in ``options`` and set ``flags``
+ accordingly.
+
+ Parameters
+ ----------
+ flags : Flags
+ options : dict
+ """
+ opt = cls()
+ opt._apply(flags, options)
+ opt.finalize(flags, options)
+ return flags
+
+ def _apply(self, flags, options):
+ # Find all Mapping instances in the class
+ mappings = {}
+ cls = type(self)
+ for k in dir(cls):
+ v = getattr(cls, k)
+ if isinstance(v, cls.Mapping):
+ mappings[k] = v
+
+ used = set()
+ for k, mapping in mappings.items():
+ if k in options:
+ v = mapping.apply(options[k])
+ setattr(flags, mapping.flag_name, v)
+ used.add(k)
+
+ unused = set(options) - used
+ if unused:
+ # Unread options?
+ m = (f"Unrecognized options: {unused}. "
+ f"Known options are {mappings.keys()}")
+ raise KeyError(m)
+
+
+_mapping = TargetOptions.Mapping
+
+
+class DefaultOptions:
+ """Defines how user-level target options are mapped to the target flags.
+ """
+ nopython = _mapping("enable_pyobject", operator.not_)
+ forceobj = _mapping("force_pyobject")
+ looplift = _mapping("enable_looplift")
+ _nrt = _mapping("nrt")
+ debug = _mapping("debuginfo")
+ boundscheck = _mapping("boundscheck")
+ nogil = _mapping("release_gil")
+ writable_args = _mapping("writable_args")
+
+ no_rewrites = _mapping("no_rewrites")
+ no_cpython_wrapper = _mapping("no_cpython_wrapper")
+ no_cfunc_wrapper = _mapping("no_cfunc_wrapper")
+
+ parallel = _mapping("auto_parallel")
+ fastmath = _mapping("fastmath")
+ error_model = _mapping("error_model")
+ inline = _mapping("inline")
+ forceinline = _mapping("forceinline")
+
+ _dbg_extend_lifetimes = _mapping("dbg_extend_lifetimes")
+ _dbg_optnone = _mapping("dbg_optnone")
+
+
+def include_default_options(*args):
+ """Returns a mixin class with a subset of the options
+
+ Parameters
+ ----------
+ *args : str
+ Option names to include.
+ """
+ glbs = {k: getattr(DefaultOptions, k) for k in args}
+
+ return type("OptionMixins", (), glbs)
diff --git a/venv/lib/python3.10/site-packages/numba/core/postproc.py b/venv/lib/python3.10/site-packages/numba/core/postproc.py
new file mode 100644
index 0000000000000000000000000000000000000000..eab5310ca3e4ca89507e6cfb700f8855891e30e7
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/postproc.py
@@ -0,0 +1,239 @@
+from functools import cached_property
+from numba.core import ir, analysis, transforms, ir_utils
+
+
+class YieldPoint(object):
+
+ def __init__(self, block, inst):
+ assert isinstance(block, ir.Block)
+ assert isinstance(inst, ir.Yield)
+ self.block = block
+ self.inst = inst
+ self.live_vars = None
+ self.weak_live_vars = None
+
+
+class GeneratorInfo(object):
+
+ def __init__(self):
+ # { index: YieldPoint }
+ self.yield_points = {}
+ # Ordered list of variable names
+ self.state_vars = []
+
+ def get_yield_points(self):
+ """
+ Return an iterable of YieldPoint instances.
+ """
+ return self.yield_points.values()
+
+
+class VariableLifetime(object):
+ """
+ For lazily building information of variable lifetime
+ """
+ def __init__(self, blocks):
+ self._blocks = blocks
+
+ @cached_property
+ def cfg(self):
+ return analysis.compute_cfg_from_blocks(self._blocks)
+
+ @cached_property
+ def usedefs(self):
+ return analysis.compute_use_defs(self._blocks)
+
+ @cached_property
+ def livemap(self):
+ return analysis.compute_live_map(self.cfg, self._blocks,
+ self.usedefs.usemap,
+ self.usedefs.defmap)
+
+ @cached_property
+ def deadmaps(self):
+ return analysis.compute_dead_maps(self.cfg, self._blocks, self.livemap,
+ self.usedefs.defmap)
+
+
+# other packages that define new nodes add calls for inserting dels
+# format: {type:function}
+ir_extension_insert_dels = {}
+
+
+class PostProcessor(object):
+ """
+ A post-processor for Numba IR.
+ """
+
+ def __init__(self, func_ir):
+ self.func_ir = func_ir
+
+ def run(self, emit_dels: bool = False, extend_lifetimes: bool = False):
+ """
+ Run the following passes over Numba IR:
+ - canonicalize the CFG
+ - emit explicit `del` instructions for variables
+ - compute lifetime of variables
+ - compute generator info (if function is a generator function)
+ """
+ self.func_ir.blocks = transforms.canonicalize_cfg(self.func_ir.blocks)
+ vlt = VariableLifetime(self.func_ir.blocks)
+ self.func_ir.variable_lifetime = vlt
+
+ bev = analysis.compute_live_variables(vlt.cfg, self.func_ir.blocks,
+ vlt.usedefs.defmap,
+ vlt.deadmaps.combined)
+ for offset, ir_block in self.func_ir.blocks.items():
+ self.func_ir.block_entry_vars[ir_block] = bev[offset]
+
+ if self.func_ir.is_generator:
+ self.func_ir.generator_info = GeneratorInfo()
+ self._compute_generator_info()
+ else:
+ self.func_ir.generator_info = None
+
+ # Emit del nodes, do this last as the generator info parsing generates
+ # and then strips dels as part of its analysis.
+ if emit_dels:
+ self._insert_var_dels(extend_lifetimes=extend_lifetimes)
+
+ def _populate_generator_info(self):
+ """
+ Fill `index` for the Yield instruction and create YieldPoints.
+ """
+ dct = self.func_ir.generator_info.yield_points
+ assert not dct, 'rerunning _populate_generator_info'
+ for block in self.func_ir.blocks.values():
+ for inst in block.body:
+ if isinstance(inst, ir.Assign):
+ yieldinst = inst.value
+ if isinstance(yieldinst, ir.Yield):
+ index = len(dct) + 1
+ yieldinst.index = index
+ yp = YieldPoint(block, yieldinst)
+ dct[yieldinst.index] = yp
+
+ def _compute_generator_info(self):
+ """
+ Compute the generator's state variables as the union of live variables
+ at all yield points.
+ """
+ # generate del info, it's used in analysis here, strip it out at the end
+ self._insert_var_dels()
+ self._populate_generator_info()
+ gi = self.func_ir.generator_info
+ for yp in gi.get_yield_points():
+ live_vars = set(self.func_ir.get_block_entry_vars(yp.block))
+ weak_live_vars = set()
+ stmts = iter(yp.block.body)
+ for stmt in stmts:
+ if isinstance(stmt, ir.Assign):
+ if stmt.value is yp.inst:
+ break
+ live_vars.add(stmt.target.name)
+ elif isinstance(stmt, ir.Del):
+ live_vars.remove(stmt.value)
+ else:
+ assert 0, "couldn't find yield point"
+ # Try to optimize out any live vars that are deleted immediately
+ # after the yield point.
+ for stmt in stmts:
+ if isinstance(stmt, ir.Del):
+ name = stmt.value
+ if name in live_vars:
+ live_vars.remove(name)
+ weak_live_vars.add(name)
+ else:
+ break
+ yp.live_vars = live_vars
+ yp.weak_live_vars = weak_live_vars
+
+ st = set()
+ for yp in gi.get_yield_points():
+ st |= yp.live_vars
+ st |= yp.weak_live_vars
+ gi.state_vars = sorted(st)
+ self.remove_dels()
+
+ def _insert_var_dels(self, extend_lifetimes=False):
+ """
+ Insert del statements for each variable.
+ Returns a 2-tuple of (variable definition map, variable deletion map)
+ which indicates variables defined and deleted in each block.
+
+ The algorithm avoids relying on explicit knowledge on loops and
+ distinguish between variables that are defined locally vs variables that
+ come from incoming blocks.
+ We start with simple usage (variable reference) and definition (variable
+ creation) maps on each block. Propagate the liveness info to predecessor
+ blocks until it stabilize, at which point we know which variables must
+ exist before entering each block. Then, we compute the end of variable
+ lives and insert del statements accordingly. Variables are deleted after
+ the last use. Variable referenced by terminators (e.g. conditional
+ branch and return) are deleted by the successors or the caller.
+ """
+ vlt = self.func_ir.variable_lifetime
+ self._patch_var_dels(vlt.deadmaps.internal, vlt.deadmaps.escaping,
+ extend_lifetimes=extend_lifetimes)
+
+ def _patch_var_dels(self, internal_dead_map, escaping_dead_map,
+ extend_lifetimes=False):
+ """
+ Insert delete in each block
+ """
+ for offset, ir_block in self.func_ir.blocks.items():
+ # for each internal var, insert delete after the last use
+ internal_dead_set = internal_dead_map[offset].copy()
+ delete_pts = []
+ # for each statement in reverse order
+ for stmt in reversed(ir_block.body[:-1]):
+ # internal vars that are used here
+ live_set = set(v.name for v in stmt.list_vars())
+ dead_set = live_set & internal_dead_set
+ for T, def_func in ir_extension_insert_dels.items():
+ if isinstance(stmt, T):
+ done_dels = def_func(stmt, dead_set)
+ dead_set -= done_dels
+ internal_dead_set -= done_dels
+ # used here but not afterwards
+ delete_pts.append((stmt, dead_set))
+ internal_dead_set -= dead_set
+
+ # rewrite body and insert dels
+ body = []
+ lastloc = ir_block.loc
+ del_store = []
+ for stmt, delete_set in reversed(delete_pts):
+ # If using extended lifetimes then the Dels are all put at the
+ # block end just ahead of the terminator, so associate their
+ # location with the terminator.
+ if extend_lifetimes:
+ lastloc = ir_block.body[-1].loc
+ else:
+ lastloc = stmt.loc
+ # Ignore dels (assuming no user inserted deletes)
+ if not isinstance(stmt, ir.Del):
+ body.append(stmt)
+ # note: the reverse sort is not necessary for correctness
+ # it is just to minimize changes to test for now
+ for var_name in sorted(delete_set, reverse=True):
+ delnode = ir.Del(var_name, loc=lastloc)
+ if extend_lifetimes:
+ del_store.append(delnode)
+ else:
+ body.append(delnode)
+ if extend_lifetimes:
+ body.extend(del_store)
+ body.append(ir_block.body[-1]) # terminator
+ ir_block.body = body
+
+ # vars to delete at the start
+ escape_dead_set = escaping_dead_map[offset]
+ for var_name in sorted(escape_dead_set):
+ ir_block.prepend(ir.Del(var_name, loc=ir_block.body[0].loc))
+
+ def remove_dels(self):
+ """
+ Strips the IR of Del nodes
+ """
+ ir_utils.remove_dels(self.func_ir.blocks)
diff --git a/venv/lib/python3.10/site-packages/numba/core/pylowering.py b/venv/lib/python3.10/site-packages/numba/core/pylowering.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca09fe3701041a74e5d9d716372ccba70b2a9330
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/pylowering.py
@@ -0,0 +1,672 @@
+"""
+Lowering implementation for object mode.
+"""
+
+
+import builtins
+import operator
+import inspect
+from functools import cached_property
+
+import llvmlite.ir
+
+from numba.core import types, utils, ir, generators, cgutils
+from numba.core.errors import (ForbiddenConstruct, LoweringError,
+ NumbaNotImplementedError)
+from numba.core.lowering import BaseLower
+
+
+# Issue #475: locals() is unsupported as calling it naively would give
+# out wrong results.
+_unsupported_builtins = set([locals])
+
+
+class _Undefined:
+ """
+ A sentinel value for undefined variable created by Expr.undef.
+ """
+ def __repr__(self):
+ return ""
+
+
+_UNDEFINED = _Undefined()
+
+
+# Map operators to methods on the PythonAPI class
+PYTHON_BINOPMAP = {
+ operator.add: ("number_add", False),
+ operator.sub: ("number_subtract", False),
+ operator.mul: ("number_multiply", False),
+ operator.truediv: ("number_truedivide", False),
+ operator.floordiv: ("number_floordivide", False),
+ operator.mod: ("number_remainder", False),
+ operator.pow: ("number_power", False),
+ operator.lshift: ("number_lshift", False),
+ operator.rshift: ("number_rshift", False),
+ operator.and_: ("number_and", False),
+ operator.or_: ("number_or", False),
+ operator.xor: ("number_xor", False),
+ # inplace operators
+ operator.iadd: ("number_add", True),
+ operator.isub: ("number_subtract", True),
+ operator.imul: ("number_multiply", True),
+ operator.itruediv: ("number_truedivide", True),
+ operator.ifloordiv: ("number_floordivide", True),
+ operator.imod: ("number_remainder", True),
+ operator.ipow: ("number_power", True),
+ operator.ilshift: ("number_lshift", True),
+ operator.irshift: ("number_rshift", True),
+ operator.iand: ("number_and", True),
+ operator.ior: ("number_or", True),
+ operator.ixor: ("number_xor", True),
+}
+
+PYTHON_BINOPMAP[operator.matmul] = ("number_matrix_multiply", False)
+PYTHON_BINOPMAP[operator.imatmul] = ("number_matrix_multiply", True)
+
+PYTHON_COMPAREOPMAP = {
+ operator.eq: '==',
+ operator.ne: '!=',
+ operator.lt: '<',
+ operator.le: '<=',
+ operator.gt: '>',
+ operator.ge: '>=',
+ operator.is_: 'is',
+ operator.is_not: 'is not',
+ operator.contains: 'in'
+}
+
+class PyLower(BaseLower):
+
+ GeneratorLower = generators.PyGeneratorLower
+
+ def init(self):
+ # Strings to be frozen into the Environment object
+ self._frozen_strings = set()
+
+ self._live_vars = set()
+
+ def pre_lower(self):
+ super(PyLower, self).pre_lower()
+ self.init_pyapi()
+
+ def post_lower(self):
+ pass
+
+ def pre_block(self, block):
+ self.init_vars(block)
+
+ def lower_inst(self, inst):
+ if isinstance(inst, ir.Assign):
+ value = self.lower_assign(inst)
+ self.storevar(value, inst.target.name)
+
+ elif isinstance(inst, ir.SetItem):
+ target = self.loadvar(inst.target.name)
+ index = self.loadvar(inst.index.name)
+ value = self.loadvar(inst.value.name)
+ ok = self.pyapi.object_setitem(target, index, value)
+ self.check_int_status(ok)
+
+ elif isinstance(inst, ir.DelItem):
+ target = self.loadvar(inst.target.name)
+ index = self.loadvar(inst.index.name)
+ ok = self.pyapi.object_delitem(target, index)
+ self.check_int_status(ok)
+
+ elif isinstance(inst, ir.SetAttr):
+ target = self.loadvar(inst.target.name)
+ value = self.loadvar(inst.value.name)
+ ok = self.pyapi.object_setattr(target,
+ self._freeze_string(inst.attr),
+ value)
+ self.check_int_status(ok)
+
+ elif isinstance(inst, ir.DelAttr):
+ target = self.loadvar(inst.target.name)
+ ok = self.pyapi.object_delattr(target,
+ self._freeze_string(inst.attr))
+ self.check_int_status(ok)
+
+ elif isinstance(inst, ir.StoreMap):
+ dct = self.loadvar(inst.dct.name)
+ key = self.loadvar(inst.key.name)
+ value = self.loadvar(inst.value.name)
+ ok = self.pyapi.dict_setitem(dct, key, value)
+ self.check_int_status(ok)
+
+ elif isinstance(inst, ir.Return):
+ retval = self.loadvar(inst.value.name)
+ if self.generator_info:
+ # StopIteration
+ # We own a reference to the "return value", but we
+ # don't return it.
+ self.pyapi.decref(retval)
+ self.genlower.return_from_generator(self)
+ return
+ # No need to incref() as the reference is already owned.
+ self.call_conv.return_value(self.builder, retval)
+
+ elif isinstance(inst, ir.Branch):
+ cond = self.loadvar(inst.cond.name)
+ if cond.type == llvmlite.ir.IntType(1):
+ istrue = cond
+ else:
+ istrue = self.pyapi.object_istrue(cond)
+ zero = llvmlite.ir.Constant(istrue.type, None)
+ pred = self.builder.icmp_unsigned('!=', istrue, zero)
+ tr = self.blkmap[inst.truebr]
+ fl = self.blkmap[inst.falsebr]
+ self.builder.cbranch(pred, tr, fl)
+
+ elif isinstance(inst, ir.Jump):
+ target = self.blkmap[inst.target]
+ self.builder.branch(target)
+
+ elif isinstance(inst, ir.Del):
+ self.delvar(inst.value)
+
+ elif isinstance(inst, ir.PopBlock):
+ pass # this is just a marker
+
+ elif isinstance(inst, ir.Raise):
+ if inst.exception is not None:
+ exc = self.loadvar(inst.exception.name)
+ # A reference will be stolen by raise_object() and another
+ # by return_exception_raised().
+ self.incref(exc)
+ else:
+ exc = None
+ self.pyapi.raise_object(exc)
+ self.return_exception_raised()
+
+ else:
+ msg = f"{type(inst)}, {inst}"
+ raise NumbaNotImplementedError(msg)
+
+ @cached_property
+ def _omitted_typobj(self):
+ """Return a `OmittedArg` type instance as a LLVM value suitable for
+ testing at runtime.
+ """
+ from numba.core.dispatcher import OmittedArg
+ return self.pyapi.unserialize(
+ self.pyapi.serialize_object(OmittedArg))
+
+ def lower_assign(self, inst):
+ """
+ The returned object must have a new reference
+ """
+ value = inst.value
+ if isinstance(value, (ir.Const, ir.FreeVar)):
+ return self.lower_const(value.value)
+ elif isinstance(value, ir.Var):
+ val = self.loadvar(value.name)
+ self.incref(val)
+ return val
+ elif isinstance(value, ir.Expr):
+ return self.lower_expr(value)
+ elif isinstance(value, ir.Global):
+ return self.lower_global(value.name, value.value)
+ elif isinstance(value, ir.Yield):
+ return self.lower_yield(value)
+ elif isinstance(value, ir.Arg):
+ param = self.func_ir.func_id.pysig.parameters.get(value.name)
+
+ obj = self.fnargs[value.index]
+ slot = cgutils.alloca_once_value(self.builder, obj)
+ # Don't check for OmittedArg unless the argument has a default
+ if param is not None and param.default is inspect.Parameter.empty:
+ self.incref(obj)
+ self.builder.store(obj, slot)
+ else:
+ # When an argument is omitted, the dispatcher hands it as
+ # _OmittedArg()
+ typobj = self.pyapi.get_type(obj)
+ is_omitted = self.builder.icmp_unsigned('==', typobj,
+ self._omitted_typobj)
+ with self.builder.if_else(is_omitted, likely=False) as (omitted, present):
+ with present:
+ self.incref(obj)
+ self.builder.store(obj, slot)
+ with omitted:
+ # The argument is omitted => get the default value
+ obj = self.pyapi.object_getattr_string(obj, 'value')
+ self.builder.store(obj, slot)
+
+ return self.builder.load(slot)
+ else:
+ raise NotImplementedError(type(value), value)
+
+ def lower_yield(self, inst):
+ yp = self.generator_info.yield_points[inst.index]
+ assert yp.inst is inst
+ self.genlower.init_generator_state(self)
+
+ # Save live vars in state
+ # We also need to save live vars that are del'ed afterwards.
+ y = generators.LowerYield(self, yp, yp.live_vars | yp.weak_live_vars)
+ y.lower_yield_suspend()
+ # Yield to caller
+ val = self.loadvar(inst.value.name)
+ # Let caller own the reference
+ self.pyapi.incref(val)
+ self.call_conv.return_value(self.builder, val)
+
+ # Resumption point
+ y.lower_yield_resume()
+ # None is returned by the yield expression
+ return self.pyapi.make_none()
+
+ def lower_binop(self, expr, op, inplace=False):
+ lhs = self.loadvar(expr.lhs.name)
+ rhs = self.loadvar(expr.rhs.name)
+ assert not isinstance(op, str)
+ if op in PYTHON_BINOPMAP:
+ fname, inplace = PYTHON_BINOPMAP[op]
+ fn = getattr(self.pyapi, fname)
+ res = fn(lhs, rhs, inplace=inplace)
+ else:
+ # Assumed to be rich comparison
+ fn = PYTHON_COMPAREOPMAP.get(expr.fn, expr.fn)
+ if fn == 'in': # 'in' and operator.contains have args reversed
+ lhs, rhs = rhs, lhs
+ res = self.pyapi.object_richcompare(lhs, rhs, fn)
+ self.check_error(res)
+ return res
+
+ def lower_expr(self, expr):
+ if expr.op == 'binop':
+ return self.lower_binop(expr, expr.fn, inplace=False)
+ elif expr.op == 'inplace_binop':
+ return self.lower_binop(expr, expr.fn, inplace=True)
+ elif expr.op == 'unary':
+ value = self.loadvar(expr.value.name)
+ if expr.fn == operator.neg:
+ res = self.pyapi.number_negative(value)
+ elif expr.fn == operator.pos:
+ res = self.pyapi.number_positive(value)
+ elif expr.fn == operator.not_:
+ res = self.pyapi.object_not(value)
+ self.check_int_status(res)
+ res = self.pyapi.bool_from_bool(res)
+ elif expr.fn == operator.invert:
+ res = self.pyapi.number_invert(value)
+ else:
+ raise NotImplementedError(expr)
+ self.check_error(res)
+ return res
+ elif expr.op == 'call':
+ argvals = [self.loadvar(a.name) for a in expr.args]
+ fn = self.loadvar(expr.func.name)
+ args = self.pyapi.tuple_pack(argvals)
+ if expr.vararg:
+ # Expand *args
+ varargs = self.pyapi.sequence_tuple(
+ self.loadvar(expr.vararg.name))
+ new_args = self.pyapi.sequence_concat(args, varargs)
+ self.decref(varargs)
+ self.decref(args)
+ args = new_args
+ if not expr.kws:
+ # No named arguments
+ ret = self.pyapi.call(fn, args, None)
+ else:
+ # Named arguments
+ keyvalues = [(k, self.loadvar(v.name)) for k, v in expr.kws]
+ kws = self.pyapi.dict_pack(keyvalues)
+ ret = self.pyapi.call(fn, args, kws)
+ self.decref(kws)
+ self.decref(args)
+ self.check_error(ret)
+ return ret
+ elif expr.op == 'getattr':
+ obj = self.loadvar(expr.value.name)
+ res = self.pyapi.object_getattr(obj, self._freeze_string(expr.attr))
+ self.check_error(res)
+ return res
+ elif expr.op == 'build_tuple':
+ items = [self.loadvar(it.name) for it in expr.items]
+ res = self.pyapi.tuple_pack(items)
+ self.check_error(res)
+ return res
+ elif expr.op == 'build_list':
+ items = [self.loadvar(it.name) for it in expr.items]
+ res = self.pyapi.list_pack(items)
+ self.check_error(res)
+ return res
+ elif expr.op == 'build_map':
+ res = self.pyapi.dict_new(expr.size)
+ self.check_error(res)
+ for k, v in expr.items:
+ key = self.loadvar(k.name)
+ value = self.loadvar(v.name)
+ ok = self.pyapi.dict_setitem(res, key, value)
+ self.check_int_status(ok)
+ return res
+ elif expr.op == 'build_set':
+ items = [self.loadvar(it.name) for it in expr.items]
+ res = self.pyapi.set_new()
+ self.check_error(res)
+ for it in items:
+ ok = self.pyapi.set_add(res, it)
+ self.check_int_status(ok)
+ return res
+ elif expr.op == 'getiter':
+ obj = self.loadvar(expr.value.name)
+ res = self.pyapi.object_getiter(obj)
+ self.check_error(res)
+ return res
+ elif expr.op == 'iternext':
+ iterobj = self.loadvar(expr.value.name)
+ item = self.pyapi.iter_next(iterobj)
+ is_valid = cgutils.is_not_null(self.builder, item)
+ pair = self.pyapi.tuple_new(2)
+ with self.builder.if_else(is_valid) as (then, otherwise):
+ with then:
+ self.pyapi.tuple_setitem(pair, 0, item)
+ with otherwise:
+ self.check_occurred()
+ # Make the tuple valid by inserting None as dummy
+ # iteration "result" (it will be ignored).
+ self.pyapi.tuple_setitem(pair, 0, self.pyapi.make_none())
+ self.pyapi.tuple_setitem(pair, 1, self.pyapi.bool_from_bool(is_valid))
+ return pair
+ elif expr.op == 'pair_first':
+ pair = self.loadvar(expr.value.name)
+ first = self.pyapi.tuple_getitem(pair, 0)
+ self.incref(first)
+ return first
+ elif expr.op == 'pair_second':
+ pair = self.loadvar(expr.value.name)
+ second = self.pyapi.tuple_getitem(pair, 1)
+ self.incref(second)
+ return second
+ elif expr.op == 'exhaust_iter':
+ iterobj = self.loadvar(expr.value.name)
+ tup = self.pyapi.sequence_tuple(iterobj)
+ self.check_error(tup)
+ # Check tuple size is as expected
+ tup_size = self.pyapi.tuple_size(tup)
+ expected_size = self.context.get_constant(types.intp, expr.count)
+ has_wrong_size = self.builder.icmp_unsigned('!=',
+ tup_size, expected_size)
+ with cgutils.if_unlikely(self.builder, has_wrong_size):
+ self.return_exception(ValueError)
+ return tup
+ elif expr.op == 'getitem':
+ value = self.loadvar(expr.value.name)
+ index = self.loadvar(expr.index.name)
+ res = self.pyapi.object_getitem(value, index)
+ self.check_error(res)
+ return res
+ elif expr.op == 'static_getitem':
+ value = self.loadvar(expr.value.name)
+ index = self.context.get_constant(types.intp, expr.index)
+ indexobj = self.pyapi.long_from_ssize_t(index)
+ self.check_error(indexobj)
+ res = self.pyapi.object_getitem(value, indexobj)
+ self.decref(indexobj)
+ self.check_error(res)
+ return res
+ elif expr.op == 'getslice':
+ target = self.loadvar(expr.target.name)
+ start = self.loadvar(expr.start.name)
+ stop = self.loadvar(expr.stop.name)
+
+ slicefn = self.get_builtin_obj("slice")
+ sliceobj = self.pyapi.call_function_objargs(slicefn, (start, stop))
+ self.decref(slicefn)
+ self.check_error(sliceobj)
+
+ res = self.pyapi.object_getitem(target, sliceobj)
+ self.check_error(res)
+
+ return res
+
+ elif expr.op == 'cast':
+ val = self.loadvar(expr.value.name)
+ self.incref(val)
+ return val
+ elif expr.op == 'phi':
+ raise LoweringError("PHI not stripped")
+
+ elif expr.op == 'null':
+ # Make null value
+ return cgutils.get_null_value(self.pyapi.pyobj)
+
+ elif expr.op == 'undef':
+ # Use a sentinel value for undefined variable
+ return self.lower_const(_UNDEFINED)
+
+ else:
+ raise NotImplementedError(expr)
+
+ def lower_const(self, const):
+ # All constants are frozen inside the environment
+ index = self.env_manager.add_const(const)
+ ret = self.env_manager.read_const(index)
+ self.check_error(ret)
+ self.incref(ret)
+ return ret
+
+ def lower_global(self, name, value):
+ """
+ 1) Check global scope dictionary.
+ 2) Check __builtins__.
+ 2a) is it a dictionary (for non __main__ module)
+ 2b) is it a module (for __main__ module)
+ """
+ moddict = self.get_module_dict()
+ obj = self.pyapi.dict_getitem(moddict, self._freeze_string(name))
+ self.incref(obj) # obj is borrowed
+
+ try:
+ if value in _unsupported_builtins:
+ raise ForbiddenConstruct("builtins %s() is not supported"
+ % name, loc=self.loc)
+ except TypeError:
+ # `value` is unhashable, ignore
+ pass
+
+ if hasattr(builtins, name):
+ obj_is_null = self.is_null(obj)
+ bbelse = self.builder.basic_block
+
+ with self.builder.if_then(obj_is_null):
+ mod = self.pyapi.dict_getitem(moddict,
+ self._freeze_string("__builtins__"))
+ builtin = self.builtin_lookup(mod, name)
+ bbif = self.builder.basic_block
+
+ retval = self.builder.phi(self.pyapi.pyobj)
+ retval.add_incoming(obj, bbelse)
+ retval.add_incoming(builtin, bbif)
+
+ else:
+ retval = obj
+ with cgutils.if_unlikely(self.builder, self.is_null(retval)):
+ self.pyapi.raise_missing_global_error(name)
+ self.return_exception_raised()
+
+ return retval
+
+ # -------------------------------------------------------------------------
+
+ def get_module_dict(self):
+ return self.env_body.globals
+
+ def get_builtin_obj(self, name):
+ # XXX The builtins dict could be bound into the environment
+ moddict = self.get_module_dict()
+ mod = self.pyapi.dict_getitem(moddict,
+ self._freeze_string("__builtins__"))
+ return self.builtin_lookup(mod, name)
+
+ def builtin_lookup(self, mod, name):
+ """
+ Args
+ ----
+ mod:
+ The __builtins__ dictionary or module, as looked up in
+ a module's globals.
+ name: str
+ The object to lookup
+ """
+ fromdict = self.pyapi.dict_getitem(mod, self._freeze_string(name))
+ self.incref(fromdict) # fromdict is borrowed
+ bbifdict = self.builder.basic_block
+
+ with cgutils.if_unlikely(self.builder, self.is_null(fromdict)):
+ # This happen if we are using the __main__ module
+ frommod = self.pyapi.object_getattr(mod, self._freeze_string(name))
+
+ with cgutils.if_unlikely(self.builder, self.is_null(frommod)):
+ self.pyapi.raise_missing_global_error(name)
+ self.return_exception_raised()
+
+ bbifmod = self.builder.basic_block
+
+ builtin = self.builder.phi(self.pyapi.pyobj)
+ builtin.add_incoming(fromdict, bbifdict)
+ builtin.add_incoming(frommod, bbifmod)
+
+ return builtin
+
+ def check_occurred(self):
+ """
+ Return if an exception occurred.
+ """
+ err_occurred = cgutils.is_not_null(self.builder,
+ self.pyapi.err_occurred())
+
+ with cgutils.if_unlikely(self.builder, err_occurred):
+ self.return_exception_raised()
+
+ def check_error(self, obj):
+ """
+ Return if *obj* is NULL.
+ """
+ with cgutils.if_unlikely(self.builder, self.is_null(obj)):
+ self.return_exception_raised()
+
+ return obj
+
+ def check_int_status(self, num, ok_value=0):
+ """
+ Raise an exception if *num* is smaller than *ok_value*.
+ """
+ ok = llvmlite.ir.Constant(num.type, ok_value)
+ pred = self.builder.icmp_signed('<', num, ok)
+ with cgutils.if_unlikely(self.builder, pred):
+ self.return_exception_raised()
+
+ def is_null(self, obj):
+ return cgutils.is_null(self.builder, obj)
+
+ def return_exception_raised(self):
+ """
+ Return with the currently raised exception.
+ """
+ self.cleanup_vars()
+ self.call_conv.return_exc(self.builder)
+
+ def init_vars(self, block):
+ """
+ Initialize live variables for *block*.
+ """
+ self._live_vars = set(self.func_ir.get_block_entry_vars(block))
+
+ def _getvar(self, name, ltype=None):
+ if name not in self.varmap:
+ self.varmap[name] = self.alloca(name, ltype=ltype)
+ return self.varmap[name]
+
+ def loadvar(self, name):
+ """
+ Load the llvm value of the variable named *name*.
+ """
+ # If this raises then the live variables analysis is wrong
+ assert name in self._live_vars, name
+ ptr = self.varmap[name]
+ val = self.builder.load(ptr)
+ with cgutils.if_unlikely(self.builder, self.is_null(val)):
+ self.pyapi.raise_missing_name_error(name)
+ self.return_exception_raised()
+ return val
+
+ def delvar(self, name):
+ """
+ Delete the variable slot with the given name. This will decref
+ the corresponding Python object.
+ """
+ # If this raises then the live variables analysis is wrong
+ self._live_vars.remove(name)
+ ptr = self._getvar(name) # initializes `name` if not already
+ self.decref(self.builder.load(ptr))
+ # This is a safety guard against double decref's, but really
+ # the IR should be correct and have only one Del per variable
+ # and code path.
+ self.builder.store(cgutils.get_null_value(ptr.type.pointee), ptr)
+
+ def storevar(self, value, name, clobber=False):
+ """
+ Stores a llvm value and allocate stack slot if necessary.
+ The llvm value can be of arbitrary type.
+ """
+ is_redefine = name in self._live_vars and not clobber
+ ptr = self._getvar(name, ltype=value.type)
+ if is_redefine:
+ old = self.builder.load(ptr)
+ else:
+ self._live_vars.add(name)
+ assert value.type == ptr.type.pointee, (str(value.type),
+ str(ptr.type.pointee))
+ self.builder.store(value, ptr)
+ # Safe to call decref even on non python object
+ if is_redefine:
+ self.decref(old)
+
+ def cleanup_vars(self):
+ """
+ Cleanup live variables.
+ """
+ for name in self._live_vars:
+ ptr = self._getvar(name)
+ self.decref(self.builder.load(ptr))
+
+ def alloca(self, name, ltype=None):
+ """
+ Allocate a stack slot and initialize it to NULL.
+ The default is to allocate a pyobject pointer.
+ Use ``ltype`` to override.
+ """
+ if ltype is None:
+ ltype = self.context.get_value_type(types.pyobject)
+ with self.builder.goto_block(self.entry_block):
+ ptr = self.builder.alloca(ltype, name=name)
+ self.builder.store(cgutils.get_null_value(ltype), ptr)
+ return ptr
+
+ def _alloca_var(self, name, fetype):
+ # This is here for API compatibility with lowering.py::Lower.
+ # NOTE: fetype is unused
+ return self.alloca(name)
+
+ def incref(self, value):
+ self.pyapi.incref(value)
+
+ def decref(self, value):
+ """
+ This is allow to be called on non pyobject pointer, in which case
+ no code is inserted.
+ """
+ lpyobj = self.context.get_value_type(types.pyobject)
+ if value.type == lpyobj:
+ self.pyapi.decref(value)
+
+ def _freeze_string(self, string):
+ """
+ Freeze a Python string object into the code.
+ """
+ return self.lower_const(string)
diff --git a/venv/lib/python3.10/site-packages/numba/core/pythonapi.py b/venv/lib/python3.10/site-packages/numba/core/pythonapi.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e29a1694f8a19f20a83a6557df56f8dc6b077e7
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/pythonapi.py
@@ -0,0 +1,1725 @@
+from collections import namedtuple
+import contextlib
+import pickle
+import hashlib
+import sys
+
+from llvmlite import ir
+from llvmlite.ir import Constant
+
+import ctypes
+from numba import _helperlib
+from numba.core import (
+ types, utils, config, lowering, cgutils, imputils, serialize,
+)
+from numba.core.utils import PYVERSION
+
+PY_UNICODE_1BYTE_KIND = _helperlib.py_unicode_1byte_kind
+PY_UNICODE_2BYTE_KIND = _helperlib.py_unicode_2byte_kind
+PY_UNICODE_4BYTE_KIND = _helperlib.py_unicode_4byte_kind
+if PYVERSION in ((3, 10), (3, 11)):
+ PY_UNICODE_WCHAR_KIND = _helperlib.py_unicode_wchar_kind
+
+
+class _Registry(object):
+
+ def __init__(self):
+ self.functions = {}
+
+ def register(self, typeclass):
+ assert issubclass(typeclass, types.Type)
+ def decorator(func):
+ if typeclass in self.functions:
+ raise KeyError("duplicate registration for %s" % (typeclass,))
+ self.functions[typeclass] = func
+ return func
+ return decorator
+
+ def lookup(self, typeclass, default=None):
+ assert issubclass(typeclass, types.Type)
+ for cls in typeclass.__mro__:
+ func = self.functions.get(cls)
+ if func is not None:
+ return func
+ return default
+
+# Registries of boxing / unboxing implementations
+_boxers = _Registry()
+_unboxers = _Registry()
+_reflectors = _Registry()
+
+box = _boxers.register
+unbox = _unboxers.register
+reflect = _reflectors.register
+
+class _BoxContext(namedtuple("_BoxContext",
+ ("context", "builder", "pyapi", "env_manager"))):
+ """
+ The facilities required by boxing implementations.
+ """
+ __slots__ = ()
+
+ def box(self, typ, val):
+ return self.pyapi.from_native_value(typ, val, self.env_manager)
+
+
+class _UnboxContext(namedtuple("_UnboxContext",
+ ("context", "builder", "pyapi"))):
+ """
+ The facilities required by unboxing implementations.
+ """
+ __slots__ = ()
+
+ def unbox(self, typ, obj):
+ return self.pyapi.to_native_value(typ, obj)
+
+
+class _ReflectContext(namedtuple("_ReflectContext",
+ ("context", "builder", "pyapi", "env_manager",
+ "is_error"))):
+ """
+ The facilities required by reflection implementations.
+ """
+ __slots__ = ()
+
+ # XXX the error bit is currently unused by consumers (e.g. PyCallWrapper)
+ def set_error(self):
+ self.builder.store(self.is_error, cgutils.true_bit)
+
+ def box(self, typ, val):
+ return self.pyapi.from_native_value(typ, val, self.env_manager)
+
+ def reflect(self, typ, val):
+ return self.pyapi.reflect_native_value(typ, val, self.env_manager)
+
+
+class NativeValue(object):
+ """
+ Encapsulate the result of converting a Python object to a native value,
+ recording whether the conversion was successful and how to cleanup.
+ """
+
+ def __init__(self, value, is_error=None, cleanup=None):
+ self.value = value
+ self.is_error = is_error if is_error is not None else cgutils.false_bit
+ self.cleanup = cleanup
+
+
+class EnvironmentManager(object):
+
+ def __init__(self, pyapi, env, env_body, env_ptr):
+ assert isinstance(env, lowering.Environment)
+ self.pyapi = pyapi
+ self.env = env
+ self.env_body = env_body
+ self.env_ptr = env_ptr
+
+ def add_const(self, const):
+ """
+ Add a constant to the environment, return its index.
+ """
+ # All constants are frozen inside the environment
+ if isinstance(const, str):
+ const = sys.intern(const)
+ for index, val in enumerate(self.env.consts):
+ if val is const:
+ break
+ else:
+ index = len(self.env.consts)
+ self.env.consts.append(const)
+ return index
+
+ def read_const(self, index):
+ """
+ Look up constant number *index* inside the environment body.
+ A borrowed reference is returned.
+
+ The returned LLVM value may have NULL value at runtime which indicates
+ an error at runtime.
+ """
+ assert index < len(self.env.consts)
+
+ builder = self.pyapi.builder
+ consts = self.env_body.consts
+ ret = cgutils.alloca_once(builder, self.pyapi.pyobj, zfill=True)
+ with builder.if_else(cgutils.is_not_null(builder, consts)) as \
+ (br_not_null, br_null):
+ with br_not_null:
+ getitem = self.pyapi.list_getitem(consts, index)
+ builder.store(getitem, ret)
+ with br_null:
+ # This can happen when the Environment is accidentally released
+ # and has subsequently been garbage collected.
+ self.pyapi.err_set_string(
+ "PyExc_RuntimeError",
+ "`env.consts` is NULL in `read_const`",
+ )
+ return builder.load(ret)
+
+
+_IteratorLoop = namedtuple('_IteratorLoop', ('value', 'do_break'))
+
+
+class PythonAPI(object):
+ """
+ Code generation facilities to call into the CPython C API (and related
+ helpers).
+ """
+
+ def __init__(self, context, builder):
+ """
+ Note: Maybe called multiple times when lowering a function
+ """
+ self.context = context
+ self.builder = builder
+
+ self.module = builder.basic_block.function.module
+ # A unique mapping of serialized objects in this module
+ try:
+ self.module.__serialized
+ except AttributeError:
+ self.module.__serialized = {}
+
+ # Initialize types
+ self.pyobj = self.context.get_argument_type(types.pyobject)
+ self.pyobjptr = self.pyobj.as_pointer()
+ self.voidptr = ir.PointerType(ir.IntType(8))
+ self.long = ir.IntType(ctypes.sizeof(ctypes.c_long) * 8)
+ self.ulong = self.long
+ self.longlong = ir.IntType(ctypes.sizeof(ctypes.c_ulonglong) * 8)
+ self.ulonglong = self.longlong
+ self.double = ir.DoubleType()
+ if config.USE_LEGACY_TYPE_SYSTEM:
+ self.py_ssize_t = self.context.get_value_type(types.intp)
+ else:
+ self.py_ssize_t = self.context.get_value_type(types.c_intp)
+ self.cstring = ir.PointerType(ir.IntType(8))
+ self.gil_state = ir.IntType(_helperlib.py_gil_state_size * 8)
+ self.py_buffer_t = ir.ArrayType(ir.IntType(8), _helperlib.py_buffer_size)
+ self.py_hash_t = self.py_ssize_t
+ self.py_unicode_1byte_kind = _helperlib.py_unicode_1byte_kind
+ self.py_unicode_2byte_kind = _helperlib.py_unicode_2byte_kind
+ self.py_unicode_4byte_kind = _helperlib.py_unicode_4byte_kind
+
+ def get_env_manager(self, env, env_body, env_ptr):
+ return EnvironmentManager(self, env, env_body, env_ptr)
+
+ def emit_environment_sentry(self, envptr, return_pyobject=False,
+ debug_msg=''):
+ """Emits LLVM code to ensure the `envptr` is not NULL
+ """
+ is_null = cgutils.is_null(self.builder, envptr)
+ with cgutils.if_unlikely(self.builder, is_null):
+ if return_pyobject:
+ fnty = self.builder.function.type.pointee
+ assert fnty.return_type == self.pyobj
+ self.err_set_string(
+ "PyExc_RuntimeError", f"missing Environment: {debug_msg}",
+ )
+ self.builder.ret(self.get_null_object())
+ else:
+ self.context.call_conv.return_user_exc(
+ self.builder, RuntimeError,
+ (f"missing Environment: {debug_msg}",),
+ )
+
+ # ------ Python API -----
+
+ #
+ # Basic object API
+ #
+
+ def incref(self, obj):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="Py_IncRef")
+ self.builder.call(fn, [obj])
+
+ def decref(self, obj):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="Py_DecRef")
+ self.builder.call(fn, [obj])
+
+ def get_type(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="numba_py_type")
+ return self.builder.call(fn, [obj])
+
+ #
+ # Argument unpacking
+ #
+
+ def parse_tuple_and_keywords(self, args, kws, fmt, keywords, *objs):
+ charptr = ir.PointerType(ir.IntType(8))
+ charptrary = ir.PointerType(charptr)
+ argtypes = [self.pyobj, self.pyobj, charptr, charptrary]
+ fnty = ir.FunctionType(ir.IntType(32), argtypes, var_arg=True)
+ fn = self._get_function(fnty, name="PyArg_ParseTupleAndKeywords")
+ return self.builder.call(fn, [args, kws, fmt, keywords] + list(objs))
+
+ def parse_tuple(self, args, fmt, *objs):
+ charptr = ir.PointerType(ir.IntType(8))
+ argtypes = [self.pyobj, charptr]
+ fnty = ir.FunctionType(ir.IntType(32), argtypes, var_arg=True)
+ fn = self._get_function(fnty, name="PyArg_ParseTuple")
+ return self.builder.call(fn, [args, fmt] + list(objs))
+
+ def unpack_tuple(self, args, name, n_min, n_max, *objs):
+ charptr = ir.PointerType(ir.IntType(8))
+ argtypes = [self.pyobj, charptr, self.py_ssize_t, self.py_ssize_t]
+ fnty = ir.FunctionType(ir.IntType(32), argtypes, var_arg=True)
+ fn = self._get_function(fnty, name="PyArg_UnpackTuple")
+ n_min = Constant(self.py_ssize_t, int(n_min))
+ n_max = Constant(self.py_ssize_t, int(n_max))
+ if isinstance(name, str):
+ name = self.context.insert_const_string(self.builder.module, name)
+ return self.builder.call(fn, [args, name, n_min, n_max] + list(objs))
+
+ #
+ # Exception and errors
+ #
+
+ def err_occurred(self):
+ fnty = ir.FunctionType(self.pyobj, ())
+ fn = self._get_function(fnty, name="PyErr_Occurred")
+ return self.builder.call(fn, ())
+
+ def err_clear(self):
+ fnty = ir.FunctionType(ir.VoidType(), ())
+ fn = self._get_function(fnty, name="PyErr_Clear")
+ return self.builder.call(fn, ())
+
+ def err_set_string(self, exctype, msg):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj, self.cstring])
+ fn = self._get_function(fnty, name="PyErr_SetString")
+ if isinstance(exctype, str):
+ exctype = self.get_c_object(exctype)
+ if isinstance(msg, str):
+ msg = self.context.insert_const_string(self.module, msg)
+ return self.builder.call(fn, (exctype, msg))
+
+ def err_format(self, exctype, msg, *format_args):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj, self.cstring], var_arg=True)
+ fn = self._get_function(fnty, name="PyErr_Format")
+ if isinstance(exctype, str):
+ exctype = self.get_c_object(exctype)
+ if isinstance(msg, str):
+ msg = self.context.insert_const_string(self.module, msg)
+ return self.builder.call(fn, (exctype, msg) + tuple(format_args))
+
+ def raise_object(self, exc=None):
+ """
+ Raise an arbitrary exception (type or value or (type, args)
+ or None - if reraising). A reference to the argument is consumed.
+ """
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="numba_do_raise")
+ if exc is None:
+ exc = self.make_none()
+ return self.builder.call(fn, (exc,))
+
+ def err_set_object(self, exctype, excval):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyErr_SetObject")
+ if isinstance(exctype, str):
+ exctype = self.get_c_object(exctype)
+ return self.builder.call(fn, (exctype, excval))
+
+ def err_set_none(self, exctype):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="PyErr_SetNone")
+ if isinstance(exctype, str):
+ exctype = self.get_c_object(exctype)
+ return self.builder.call(fn, (exctype,))
+
+ def err_write_unraisable(self, obj):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="PyErr_WriteUnraisable")
+ return self.builder.call(fn, (obj,))
+
+ def err_fetch(self, pty, pval, ptb):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobjptr] * 3)
+ fn = self._get_function(fnty, name="PyErr_Fetch")
+ return self.builder.call(fn, (pty, pval, ptb))
+
+ def err_restore(self, ty, val, tb):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj] * 3)
+ fn = self._get_function(fnty, name="PyErr_Restore")
+ return self.builder.call(fn, (ty, val, tb))
+
+ @contextlib.contextmanager
+ def err_push(self, keep_new=False):
+ """
+ Temporarily push the current error indicator while the code
+ block is executed. If *keep_new* is True and the code block
+ raises a new error, the new error is kept, otherwise the old
+ error indicator is restored at the end of the block.
+ """
+ pty, pval, ptb = [cgutils.alloca_once(self.builder, self.pyobj)
+ for i in range(3)]
+ self.err_fetch(pty, pval, ptb)
+ yield
+ ty = self.builder.load(pty)
+ val = self.builder.load(pval)
+ tb = self.builder.load(ptb)
+ if keep_new:
+ new_error = cgutils.is_not_null(self.builder, self.err_occurred())
+ with self.builder.if_else(new_error, likely=False) as (if_error, if_ok):
+ with if_error:
+ # Code block raised an error, keep it
+ self.decref(ty)
+ self.decref(val)
+ self.decref(tb)
+ with if_ok:
+ # Restore previous error
+ self.err_restore(ty, val, tb)
+ else:
+ self.err_restore(ty, val, tb)
+
+ def get_c_object(self, name):
+ """
+ Get a Python object through its C-accessible *name*
+ (e.g. "PyExc_ValueError"). The underlying variable must be
+ a `PyObject *`, and the value of that pointer is returned.
+ """
+ # A LLVM global variable is implicitly a pointer to the declared
+ # type, so fix up by using pyobj.pointee.
+ return self.context.get_c_value(self.builder, self.pyobj.pointee, name,
+ dllimport=True)
+
+ def raise_missing_global_error(self, name):
+ msg = "global name '%s' is not defined" % name
+ cstr = self.context.insert_const_string(self.module, msg)
+ self.err_set_string("PyExc_NameError", cstr)
+
+ def raise_missing_name_error(self, name):
+ msg = "name '%s' is not defined" % name
+ cstr = self.context.insert_const_string(self.module, msg)
+ self.err_set_string("PyExc_NameError", cstr)
+
+ def fatal_error(self, msg):
+ fnty = ir.FunctionType(ir.VoidType(), [self.cstring])
+ fn = self._get_function(fnty, name="Py_FatalError")
+ fn.attributes.add("noreturn")
+ cstr = self.context.insert_const_string(self.module, msg)
+ self.builder.call(fn, (cstr,))
+
+ #
+ # Concrete dict API
+ #
+
+ def dict_getitem_string(self, dic, name):
+ """Lookup name inside dict
+
+ Returns a borrowed reference
+ """
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.cstring])
+ fn = self._get_function(fnty, name="PyDict_GetItemString")
+ cstr = self.context.insert_const_string(self.module, name)
+ return self.builder.call(fn, [dic, cstr])
+
+ def dict_getitem(self, dic, name):
+ """Lookup name inside dict
+
+ Returns a borrowed reference
+ """
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyDict_GetItem")
+ return self.builder.call(fn, [dic, name])
+
+ def dict_new(self, presize=0):
+ if presize == 0:
+ fnty = ir.FunctionType(self.pyobj, ())
+ fn = self._get_function(fnty, name="PyDict_New")
+ return self.builder.call(fn, ())
+ else:
+ fnty = ir.FunctionType(self.pyobj, [self.py_ssize_t])
+ fn = self._get_function(fnty, name="_PyDict_NewPresized")
+ return self.builder.call(fn,
+ [Constant(self.py_ssize_t, int(presize))])
+
+ def dict_setitem(self, dictobj, nameobj, valobj):
+ fnty = ir.FunctionType(ir.IntType(32), (self.pyobj, self.pyobj,
+ self.pyobj))
+ fn = self._get_function(fnty, name="PyDict_SetItem")
+ return self.builder.call(fn, (dictobj, nameobj, valobj))
+
+ def dict_setitem_string(self, dictobj, name, valobj):
+ fnty = ir.FunctionType(ir.IntType(32), (self.pyobj, self.cstring,
+ self.pyobj))
+ fn = self._get_function(fnty, name="PyDict_SetItemString")
+ cstr = self.context.insert_const_string(self.module, name)
+ return self.builder.call(fn, (dictobj, cstr, valobj))
+
+ def dict_pack(self, keyvalues):
+ """
+ Args
+ -----
+ keyvalues: iterable of (str, llvm.Value of PyObject*)
+ """
+ dictobj = self.dict_new()
+ with self.if_object_ok(dictobj):
+ for k, v in keyvalues:
+ self.dict_setitem_string(dictobj, k, v)
+ return dictobj
+
+ #
+ # Concrete number APIs
+ #
+
+ def float_from_double(self, fval):
+ fnty = ir.FunctionType(self.pyobj, [self.double])
+ fn = self._get_function(fnty, name="PyFloat_FromDouble")
+ return self.builder.call(fn, [fval])
+
+ def number_as_ssize_t(self, numobj):
+ fnty = ir.FunctionType(self.py_ssize_t, [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_AsSsize_t")
+ # We don't want any clipping, so pass OverflowError as the 2nd arg
+ exc_class = self.get_c_object("PyExc_OverflowError")
+ return self.builder.call(fn, [numobj, exc_class])
+
+ def number_long(self, numobj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_Long")
+ return self.builder.call(fn, [numobj])
+
+ def long_as_ulonglong(self, numobj):
+ fnty = ir.FunctionType(self.ulonglong, [self.pyobj])
+ fn = self._get_function(fnty, name="PyLong_AsUnsignedLongLong")
+ return self.builder.call(fn, [numobj])
+
+ def long_as_longlong(self, numobj):
+ fnty = ir.FunctionType(self.ulonglong, [self.pyobj])
+ fn = self._get_function(fnty, name="PyLong_AsLongLong")
+ return self.builder.call(fn, [numobj])
+
+ def long_as_voidptr(self, numobj):
+ """
+ Convert the given Python integer to a void*. This is recommended
+ over number_as_ssize_t as it isn't affected by signedness.
+ """
+ fnty = ir.FunctionType(self.voidptr, [self.pyobj])
+ fn = self._get_function(fnty, name="PyLong_AsVoidPtr")
+ return self.builder.call(fn, [numobj])
+
+ def _long_from_native_int(self, ival, func_name, native_int_type,
+ signed):
+ fnty = ir.FunctionType(self.pyobj, [native_int_type])
+ fn = self._get_function(fnty, name=func_name)
+ resptr = cgutils.alloca_once(self.builder, self.pyobj)
+ fn = self._get_function(fnty, name=func_name)
+ self.builder.store(self.builder.call(fn, [ival]), resptr)
+
+ return self.builder.load(resptr)
+
+ def long_from_long(self, ival):
+ func_name = "PyLong_FromLong"
+ fnty = ir.FunctionType(self.pyobj, [self.long])
+ fn = self._get_function(fnty, name=func_name)
+ return self.builder.call(fn, [ival])
+
+ def long_from_ulong(self, ival):
+ return self._long_from_native_int(ival, "PyLong_FromUnsignedLong",
+ self.long, signed=False)
+
+ def long_from_ssize_t(self, ival):
+ return self._long_from_native_int(ival, "PyLong_FromSsize_t",
+ self.py_ssize_t, signed=True)
+
+ def long_from_longlong(self, ival):
+ return self._long_from_native_int(ival, "PyLong_FromLongLong",
+ self.longlong, signed=True)
+
+ def long_from_ulonglong(self, ival):
+ return self._long_from_native_int(ival, "PyLong_FromUnsignedLongLong",
+ self.ulonglong, signed=False)
+
+ def long_from_signed_int(self, ival):
+ """
+ Return a Python integer from any native integer value.
+ """
+ bits = ival.type.width
+ if bits <= self.long.width:
+ return self.long_from_long(self.builder.sext(ival, self.long))
+ elif bits <= self.longlong.width:
+ return self.long_from_longlong(self.builder.sext(ival, self.longlong))
+ else:
+ raise OverflowError("integer too big (%d bits)" % (bits))
+
+ def long_from_unsigned_int(self, ival):
+ """
+ Same as long_from_signed_int, but for unsigned values.
+ """
+ bits = ival.type.width
+ if bits <= self.ulong.width:
+ return self.long_from_ulong(self.builder.zext(ival, self.ulong))
+ elif bits <= self.ulonglong.width:
+ return self.long_from_ulonglong(self.builder.zext(ival, self.ulonglong))
+ else:
+ raise OverflowError("integer too big (%d bits)" % (bits))
+
+ def _get_number_operator(self, name):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_%s" % name)
+ return fn
+
+ def _call_number_operator(self, name, lhs, rhs, inplace=False):
+ if inplace:
+ name = "InPlace" + name
+ fn = self._get_number_operator(name)
+ return self.builder.call(fn, [lhs, rhs])
+
+ def number_add(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Add", lhs, rhs, inplace=inplace)
+
+ def number_subtract(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Subtract", lhs, rhs, inplace=inplace)
+
+ def number_multiply(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Multiply", lhs, rhs, inplace=inplace)
+
+ def number_truedivide(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("TrueDivide", lhs, rhs, inplace=inplace)
+
+ def number_floordivide(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("FloorDivide", lhs, rhs, inplace=inplace)
+
+ def number_remainder(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Remainder", lhs, rhs, inplace=inplace)
+
+ def number_matrix_multiply(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("MatrixMultiply", lhs, rhs, inplace=inplace)
+
+ def number_lshift(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Lshift", lhs, rhs, inplace=inplace)
+
+ def number_rshift(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Rshift", lhs, rhs, inplace=inplace)
+
+ def number_and(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("And", lhs, rhs, inplace=inplace)
+
+ def number_or(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Or", lhs, rhs, inplace=inplace)
+
+ def number_xor(self, lhs, rhs, inplace=False):
+ return self._call_number_operator("Xor", lhs, rhs, inplace=inplace)
+
+ def number_power(self, lhs, rhs, inplace=False):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj] * 3)
+ fname = "PyNumber_InPlacePower" if inplace else "PyNumber_Power"
+ fn = self._get_function(fnty, fname)
+ return self.builder.call(fn, [lhs, rhs, self.borrow_none()])
+
+ def number_negative(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_Negative")
+ return self.builder.call(fn, (obj,))
+
+ def number_positive(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_Positive")
+ return self.builder.call(fn, (obj,))
+
+ def number_float(self, val):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_Float")
+ return self.builder.call(fn, [val])
+
+ def number_invert(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyNumber_Invert")
+ return self.builder.call(fn, (obj,))
+
+ def float_as_double(self, fobj):
+ fnty = ir.FunctionType(self.double, [self.pyobj])
+ fn = self._get_function(fnty, name="PyFloat_AsDouble")
+ return self.builder.call(fn, [fobj])
+
+ def bool_from_bool(self, bval):
+ """
+ Get a Python bool from a LLVM boolean.
+ """
+ longval = self.builder.zext(bval, self.long)
+ return self.bool_from_long(longval)
+
+ def bool_from_long(self, ival):
+ fnty = ir.FunctionType(self.pyobj, [self.long])
+ fn = self._get_function(fnty, name="PyBool_FromLong")
+ return self.builder.call(fn, [ival])
+
+ def complex_from_doubles(self, realval, imagval):
+ fnty = ir.FunctionType(self.pyobj, [ir.DoubleType(), ir.DoubleType()])
+ fn = self._get_function(fnty, name="PyComplex_FromDoubles")
+ return self.builder.call(fn, [realval, imagval])
+
+ def complex_real_as_double(self, cobj):
+ fnty = ir.FunctionType(ir.DoubleType(), [self.pyobj])
+ fn = self._get_function(fnty, name="PyComplex_RealAsDouble")
+ return self.builder.call(fn, [cobj])
+
+ def complex_imag_as_double(self, cobj):
+ fnty = ir.FunctionType(ir.DoubleType(), [self.pyobj])
+ fn = self._get_function(fnty, name="PyComplex_ImagAsDouble")
+ return self.builder.call(fn, [cobj])
+
+ #
+ # Concrete slice API
+ #
+ def slice_as_ints(self, obj):
+ """
+ Read the members of a slice of integers.
+
+ Returns a (ok, start, stop, step) tuple where ok is a boolean and
+ the following members are pointer-sized ints.
+ """
+ pstart = cgutils.alloca_once(self.builder, self.py_ssize_t)
+ pstop = cgutils.alloca_once(self.builder, self.py_ssize_t)
+ pstep = cgutils.alloca_once(self.builder, self.py_ssize_t)
+ fnty = ir.FunctionType(ir.IntType(32),
+ [self.pyobj] + [self.py_ssize_t.as_pointer()] * 3)
+ fn = self._get_function(fnty, name="numba_unpack_slice")
+ res = self.builder.call(fn, (obj, pstart, pstop, pstep))
+ start = self.builder.load(pstart)
+ stop = self.builder.load(pstop)
+ step = self.builder.load(pstep)
+ return cgutils.is_null(self.builder, res), start, stop, step
+
+ #
+ # List and sequence APIs
+ #
+
+ def sequence_getslice(self, obj, start, stop):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.py_ssize_t,
+ self.py_ssize_t])
+ fn = self._get_function(fnty, name="PySequence_GetSlice")
+ return self.builder.call(fn, (obj, start, stop))
+
+ def sequence_tuple(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PySequence_Tuple")
+ return self.builder.call(fn, [obj])
+
+ def sequence_concat(self, obj1, obj2):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PySequence_Concat")
+ return self.builder.call(fn, [obj1, obj2])
+
+ def list_new(self, szval):
+ fnty = ir.FunctionType(self.pyobj, [self.py_ssize_t])
+ fn = self._get_function(fnty, name="PyList_New")
+ return self.builder.call(fn, [szval])
+
+ def list_size(self, lst):
+ fnty = ir.FunctionType(self.py_ssize_t, [self.pyobj])
+ fn = self._get_function(fnty, name="PyList_Size")
+ return self.builder.call(fn, [lst])
+
+ def list_append(self, lst, val):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyList_Append")
+ return self.builder.call(fn, [lst, val])
+
+ def list_setitem(self, lst, idx, val):
+ """
+ Warning: Steals reference to ``val``
+ """
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.py_ssize_t,
+ self.pyobj])
+ fn = self._get_function(fnty, name="PyList_SetItem")
+ return self.builder.call(fn, [lst, idx, val])
+
+ def list_getitem(self, lst, idx):
+ """
+ Returns a borrowed reference.
+ """
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.py_ssize_t])
+ fn = self._get_function(fnty, name="PyList_GetItem")
+ if isinstance(idx, int):
+ idx = self.context.get_constant(types.intp, idx)
+ return self.builder.call(fn, [lst, idx])
+
+ def list_setslice(self, lst, start, stop, obj):
+ if obj is None:
+ obj = self.get_null_object()
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.py_ssize_t,
+ self.py_ssize_t, self.pyobj])
+ fn = self._get_function(fnty, name="PyList_SetSlice")
+ return self.builder.call(fn, (lst, start, stop, obj))
+
+
+ #
+ # Concrete tuple API
+ #
+
+ def tuple_getitem(self, tup, idx):
+ """
+ Borrow reference
+ """
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.py_ssize_t])
+ fn = self._get_function(fnty, name="PyTuple_GetItem")
+ idx = self.context.get_constant(types.intp, idx)
+ return self.builder.call(fn, [tup, idx])
+
+ def tuple_pack(self, items):
+ fnty = ir.FunctionType(self.pyobj, [self.py_ssize_t], var_arg=True)
+ fn = self._get_function(fnty, name="PyTuple_Pack")
+ n = self.context.get_constant(types.intp, len(items))
+ args = [n]
+ args.extend(items)
+ return self.builder.call(fn, args)
+
+ def tuple_size(self, tup):
+ fnty = ir.FunctionType(self.py_ssize_t, [self.pyobj])
+ fn = self._get_function(fnty, name="PyTuple_Size")
+ return self.builder.call(fn, [tup])
+
+ def tuple_new(self, count):
+ fnty = ir.FunctionType(self.pyobj, [self.py_ssize_t])
+ fn = self._get_function(fnty, name='PyTuple_New')
+ return self.builder.call(fn, [self.py_ssize_t(count)])
+
+ def tuple_setitem(self, tuple_val, index, item):
+ """
+ Steals a reference to `item`.
+ """
+ fnty = ir.FunctionType(ir.IntType(32),
+ [self.pyobj, self.py_ssize_t, self.pyobj])
+ setitem_fn = self._get_function(fnty, name='PyTuple_SetItem')
+ index = self.py_ssize_t(index)
+ self.builder.call(setitem_fn, [tuple_val, index, item])
+
+ #
+ # Concrete set API
+ #
+
+ def set_new(self, iterable=None):
+ if iterable is None:
+ iterable = self.get_null_object()
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PySet_New")
+ return self.builder.call(fn, [iterable])
+
+ def set_add(self, set, value):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PySet_Add")
+ return self.builder.call(fn, [set, value])
+
+ def set_clear(self, set):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj])
+ fn = self._get_function(fnty, name="PySet_Clear")
+ return self.builder.call(fn, [set])
+
+ def set_size(self, set):
+ fnty = ir.FunctionType(self.py_ssize_t, [self.pyobj])
+ fn = self._get_function(fnty, name="PySet_Size")
+ return self.builder.call(fn, [set])
+
+ def set_update(self, set, iterable):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="_PySet_Update")
+ return self.builder.call(fn, [set, iterable])
+
+ def set_next_entry(self, set, posptr, keyptr, hashptr):
+ fnty = ir.FunctionType(ir.IntType(32),
+ [self.pyobj, self.py_ssize_t.as_pointer(),
+ self.pyobj.as_pointer(), self.py_hash_t.as_pointer()])
+ fn = self._get_function(fnty, name="_PySet_NextEntry")
+ return self.builder.call(fn, (set, posptr, keyptr, hashptr))
+
+ @contextlib.contextmanager
+ def set_iterate(self, set):
+ builder = self.builder
+
+ hashptr = cgutils.alloca_once(builder, self.py_hash_t, name="hashptr")
+ keyptr = cgutils.alloca_once(builder, self.pyobj, name="keyptr")
+ posptr = cgutils.alloca_once_value(builder,
+ Constant(self.py_ssize_t, 0),
+ name="posptr")
+
+ bb_body = builder.append_basic_block("bb_body")
+ bb_end = builder.append_basic_block("bb_end")
+
+ builder.branch(bb_body)
+ def do_break():
+ builder.branch(bb_end)
+
+ with builder.goto_block(bb_body):
+ r = self.set_next_entry(set, posptr, keyptr, hashptr)
+ finished = cgutils.is_null(builder, r)
+ with builder.if_then(finished, likely=False):
+ builder.branch(bb_end)
+ yield _IteratorLoop(builder.load(keyptr), do_break)
+ builder.branch(bb_body)
+
+ builder.position_at_end(bb_end)
+
+ #
+ # GIL APIs
+ #
+
+ def gil_ensure(self):
+ """
+ Ensure the GIL is acquired.
+ The returned value must be consumed by gil_release().
+ """
+ gilptrty = ir.PointerType(self.gil_state)
+ fnty = ir.FunctionType(ir.VoidType(), [gilptrty])
+ fn = self._get_function(fnty, "numba_gil_ensure")
+ gilptr = cgutils.alloca_once(self.builder, self.gil_state)
+ self.builder.call(fn, [gilptr])
+ return gilptr
+
+ def gil_release(self, gil):
+ """
+ Release the acquired GIL by gil_ensure().
+ Must be paired with a gil_ensure().
+ """
+ gilptrty = ir.PointerType(self.gil_state)
+ fnty = ir.FunctionType(ir.VoidType(), [gilptrty])
+ fn = self._get_function(fnty, "numba_gil_release")
+ return self.builder.call(fn, [gil])
+
+ def save_thread(self):
+ """
+ Release the GIL and return the former thread state
+ (an opaque non-NULL pointer).
+ """
+ fnty = ir.FunctionType(self.voidptr, [])
+ fn = self._get_function(fnty, name="PyEval_SaveThread")
+ return self.builder.call(fn, [])
+
+ def restore_thread(self, thread_state):
+ """
+ Restore the given thread state by reacquiring the GIL.
+ """
+ fnty = ir.FunctionType(ir.VoidType(), [self.voidptr])
+ fn = self._get_function(fnty, name="PyEval_RestoreThread")
+ self.builder.call(fn, [thread_state])
+
+ #
+ # Generic object private data (a way of associating an arbitrary void *
+ # pointer to an arbitrary Python object).
+ #
+
+ def object_get_private_data(self, obj):
+ fnty = ir.FunctionType(self.voidptr, [self.pyobj])
+ fn = self._get_function(fnty, name="numba_get_pyobject_private_data")
+ return self.builder.call(fn, (obj,))
+
+ def object_set_private_data(self, obj, ptr):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj, self.voidptr])
+ fn = self._get_function(fnty, name="numba_set_pyobject_private_data")
+ return self.builder.call(fn, (obj, ptr))
+
+ def object_reset_private_data(self, obj):
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="numba_reset_pyobject_private_data")
+ return self.builder.call(fn, (obj,))
+
+
+ #
+ # Other APIs (organize them better!)
+ #
+
+ def import_module(self, modname):
+ fnty = ir.FunctionType(self.pyobj, [self.cstring])
+ fn = self._get_function(fnty, name="PyImport_ImportModule")
+ return self.builder.call(fn, [modname])
+
+ def call_function_objargs(self, callee, objargs):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj], var_arg=True)
+ fn = self._get_function(fnty, name="PyObject_CallFunctionObjArgs")
+ args = [callee] + list(objargs)
+ args.append(self.context.get_constant_null(types.pyobject))
+ return self.builder.call(fn, args)
+
+ def call_method(self, callee, method, objargs=()):
+ cname = self.context.insert_const_string(self.module, method)
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.cstring, self.cstring],
+ var_arg=True)
+ fn = self._get_function(fnty, name="PyObject_CallMethod")
+ fmt = 'O' * len(objargs)
+ cfmt = self.context.insert_const_string(self.module, fmt)
+ args = [callee, cname, cfmt]
+ if objargs:
+ args.extend(objargs)
+ args.append(self.context.get_constant_null(types.pyobject))
+ return self.builder.call(fn, args)
+
+ def call(self, callee, args=None, kws=None):
+ if args_was_none := args is None:
+ args = self.tuple_new(0)
+ if kws is None:
+ kws = self.get_null_object()
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj] * 3)
+ fn = self._get_function(fnty, name="PyObject_Call")
+ result = self.builder.call(fn, (callee, args, kws))
+ if args_was_none:
+ self.decref(args)
+ return result
+
+ def object_type(self, obj):
+ """Emit a call to ``PyObject_Type(obj)`` to get the type of ``obj``.
+ """
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_Type")
+ return self.builder.call(fn, (obj,))
+
+ def object_istrue(self, obj):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_IsTrue")
+ return self.builder.call(fn, [obj])
+
+ def object_not(self, obj):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_Not")
+ return self.builder.call(fn, [obj])
+
+ def object_richcompare(self, lhs, rhs, opstr):
+ """
+ Refer to Python source Include/object.h for macros definition
+ of the opid.
+ """
+ ops = ['<', '<=', '==', '!=', '>', '>=']
+ if opstr in ops:
+ opid = ops.index(opstr)
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj, ir.IntType(32)])
+ fn = self._get_function(fnty, name="PyObject_RichCompare")
+ lopid = self.context.get_constant(types.int32, opid)
+ return self.builder.call(fn, (lhs, rhs, lopid))
+ elif opstr == 'is':
+ bitflag = self.builder.icmp_unsigned('==', lhs, rhs)
+ return self.bool_from_bool(bitflag)
+ elif opstr == 'is not':
+ bitflag = self.builder.icmp_unsigned('!=', lhs, rhs)
+ return self.bool_from_bool(bitflag)
+ elif opstr in ('in', 'not in'):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PySequence_Contains")
+ status = self.builder.call(fn, (rhs, lhs))
+ negone = self.context.get_constant(types.int32, -1)
+ is_good = self.builder.icmp_unsigned('!=', status, negone)
+ # Stack allocate output and initialize to Null
+ outptr = cgutils.alloca_once_value(self.builder,
+ Constant(self.pyobj, None))
+ # If PySequence_Contains returns non-error value
+ with cgutils.if_likely(self.builder, is_good):
+ if opstr == 'not in':
+ status = self.builder.not_(status)
+ # Store the status as a boolean object
+ truncated = self.builder.trunc(status, ir.IntType(1))
+ self.builder.store(self.bool_from_bool(truncated),
+ outptr)
+
+ return self.builder.load(outptr)
+ else:
+ raise NotImplementedError("Unknown operator {op!r}".format(
+ op=opstr))
+
+ def iter_next(self, iterobj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyIter_Next")
+ return self.builder.call(fn, [iterobj])
+
+ def object_getiter(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_GetIter")
+ return self.builder.call(fn, [obj])
+
+ def object_getattr_string(self, obj, attr):
+ cstr = self.context.insert_const_string(self.module, attr)
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.cstring])
+ fn = self._get_function(fnty, name="PyObject_GetAttrString")
+ return self.builder.call(fn, [obj, cstr])
+
+ def object_getattr(self, obj, attr):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_GetAttr")
+ return self.builder.call(fn, [obj, attr])
+
+ def object_setattr_string(self, obj, attr, val):
+ cstr = self.context.insert_const_string(self.module, attr)
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.cstring, self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_SetAttrString")
+ return self.builder.call(fn, [obj, cstr, val])
+
+ def object_setattr(self, obj, attr, val):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_SetAttr")
+ return self.builder.call(fn, [obj, attr, val])
+
+ def object_delattr_string(self, obj, attr):
+ # PyObject_DelAttrString() is actually a C macro calling
+ # PyObject_SetAttrString() with value == NULL.
+ return self.object_setattr_string(obj, attr, self.get_null_object())
+
+ def object_delattr(self, obj, attr):
+ # PyObject_DelAttr() is actually a C macro calling
+ # PyObject_SetAttr() with value == NULL.
+ return self.object_setattr(obj, attr, self.get_null_object())
+
+ def object_getitem(self, obj, key):
+ """
+ Return obj[key]
+ """
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_GetItem")
+ return self.builder.call(fn, (obj, key))
+
+ def object_setitem(self, obj, key, val):
+ """
+ obj[key] = val
+ """
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_SetItem")
+ return self.builder.call(fn, (obj, key, val))
+
+ def object_delitem(self, obj, key):
+ """
+ del obj[key]
+ """
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_DelItem")
+ return self.builder.call(fn, (obj, key))
+
+ def string_as_string(self, strobj):
+ fnty = ir.FunctionType(self.cstring, [self.pyobj])
+ fname = "PyUnicode_AsUTF8"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [strobj])
+
+ def string_as_string_and_size(self, strobj):
+ """
+ Returns a tuple of ``(ok, buffer, length)``.
+ The ``ok`` is i1 value that is set if ok.
+ The ``buffer`` is a i8* of the output buffer.
+ The ``length`` is a i32/i64 (py_ssize_t) of the length of the buffer.
+ """
+
+ p_length = cgutils.alloca_once(self.builder, self.py_ssize_t)
+ fnty = ir.FunctionType(self.cstring, [self.pyobj,
+ self.py_ssize_t.as_pointer()])
+ fname = "PyUnicode_AsUTF8AndSize"
+ fn = self._get_function(fnty, name=fname)
+
+ buffer = self.builder.call(fn, [strobj, p_length])
+ ok = self.builder.icmp_unsigned('!=',
+ Constant(buffer.type, None),
+ buffer)
+ return (ok, buffer, self.builder.load(p_length))
+
+ def string_as_string_size_and_kind(self, strobj):
+ """
+ Returns a tuple of ``(ok, buffer, length, kind)``.
+ The ``ok`` is i1 value that is set if ok.
+ The ``buffer`` is a i8* of the output buffer.
+ The ``length`` is a i32/i64 (py_ssize_t) of the length of the buffer.
+ The ``kind`` is a i32 (int32) of the Unicode kind constant
+ The ``hash`` is a long/uint64_t (py_hash_t) of the Unicode constant hash
+ """
+ p_length = cgutils.alloca_once(self.builder, self.py_ssize_t)
+ p_kind = cgutils.alloca_once(self.builder, ir.IntType(32))
+ p_ascii = cgutils.alloca_once(self.builder, ir.IntType(32))
+ p_hash = cgutils.alloca_once(self.builder, self.py_hash_t)
+ fnty = ir.FunctionType(self.cstring, [self.pyobj,
+ self.py_ssize_t.as_pointer(),
+ ir.IntType(32).as_pointer(),
+ ir.IntType(32).as_pointer(),
+ self.py_hash_t.as_pointer()])
+ fname = "numba_extract_unicode"
+ fn = self._get_function(fnty, name=fname)
+
+ buffer = self.builder.call(
+ fn, [strobj, p_length, p_kind, p_ascii, p_hash])
+ ok = self.builder.icmp_unsigned('!=',
+ Constant(buffer.type, None),
+ buffer)
+ return (ok, buffer, self.builder.load(p_length),
+ self.builder.load(p_kind), self.builder.load(p_ascii),
+ self.builder.load(p_hash))
+
+ def string_from_string_and_size(self, string, size):
+ fnty = ir.FunctionType(self.pyobj, [self.cstring, self.py_ssize_t])
+ fname = "PyString_FromStringAndSize"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [string, size])
+
+ def string_from_string(self, string):
+ fnty = ir.FunctionType(self.pyobj, [self.cstring])
+ fname = "PyUnicode_FromString"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [string])
+
+ def string_from_kind_and_data(self, kind, string, size):
+ fnty = ir.FunctionType(self.pyobj, [ir.IntType(32), self.cstring, self.py_ssize_t])
+ fname = "PyUnicode_FromKindAndData"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [kind, string, size])
+
+ def bytes_as_string(self, obj):
+ fnty = ir.FunctionType(self.cstring, [self.pyobj])
+ fname = "PyBytes_AsString"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [obj])
+
+ def bytes_as_string_and_size(self, obj, p_buffer, p_length):
+ fnty = ir.FunctionType(
+ ir.IntType(32),
+ [self.pyobj, self.cstring.as_pointer(), self.py_ssize_t.as_pointer()],
+ )
+ fname = "PyBytes_AsStringAndSize"
+ fn = self._get_function(fnty, name=fname)
+ result = self.builder.call(fn, [obj, p_buffer, p_length])
+ ok = self.builder.icmp_signed("!=", Constant(result.type, -1), result)
+ return ok
+
+ def bytes_from_string_and_size(self, string, size):
+ fnty = ir.FunctionType(self.pyobj, [self.cstring, self.py_ssize_t])
+ fname = "PyBytes_FromStringAndSize"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [string, size])
+
+ def object_hash(self, obj):
+ fnty = ir.FunctionType(self.py_hash_t, [self.pyobj, ])
+ fname = "PyObject_Hash"
+ fn = self._get_function(fnty, name=fname)
+ return self.builder.call(fn, [obj,])
+
+ def object_str(self, obj):
+ fnty = ir.FunctionType(self.pyobj, [self.pyobj])
+ fn = self._get_function(fnty, name="PyObject_Str")
+ return self.builder.call(fn, [obj])
+
+ def make_none(self):
+ obj = self.borrow_none()
+ self.incref(obj)
+ return obj
+
+ def borrow_none(self):
+ return self.get_c_object("_Py_NoneStruct")
+
+ def sys_write_stdout(self, fmt, *args):
+ fnty = ir.FunctionType(ir.VoidType(), [self.cstring], var_arg=True)
+ fn = self._get_function(fnty, name="PySys_FormatStdout")
+ return self.builder.call(fn, (fmt,) + args)
+
+ def object_dump(self, obj):
+ """
+ Dump a Python object on C stderr. For debugging purposes.
+ """
+ fnty = ir.FunctionType(ir.VoidType(), [self.pyobj])
+ fn = self._get_function(fnty, name="_PyObject_Dump")
+ return self.builder.call(fn, (obj,))
+
+ #
+ # NRT (Numba runtime) APIs
+ #
+
+ def nrt_adapt_ndarray_to_python(self, aryty, ary, dtypeptr):
+ assert self.context.enable_nrt, "NRT required"
+
+ intty = ir.IntType(32)
+ # Embed the Python type of the array (maybe subclass) in the LLVM IR.
+ serial_aryty_pytype = self.unserialize(self.serialize_object(aryty.box_type))
+
+ fnty = ir.FunctionType(self.pyobj,
+ [self.voidptr, self.pyobj, intty, intty, self.pyobj])
+ fn = self._get_function(fnty, name="NRT_adapt_ndarray_to_python_acqref")
+ fn.args[0].add_attribute('nocapture')
+
+ ndim = self.context.get_constant(types.int32, aryty.ndim)
+ writable = self.context.get_constant(types.int32, int(aryty.mutable))
+
+ aryptr = cgutils.alloca_once_value(self.builder, ary)
+ return self.builder.call(fn, [self.builder.bitcast(aryptr,
+ self.voidptr),
+ serial_aryty_pytype,
+ ndim, writable, dtypeptr])
+
+ def nrt_meminfo_new_from_pyobject(self, data, pyobj):
+ """
+ Allocate a new MemInfo with data payload borrowed from a python
+ object.
+ """
+ mod = self.builder.module
+ fnty = ir.FunctionType(
+ cgutils.voidptr_t,
+ [cgutils.voidptr_t, cgutils.voidptr_t],
+ )
+ fn = cgutils.get_or_insert_function(
+ mod,
+ fnty,
+ "NRT_meminfo_new_from_pyobject",
+ )
+ fn.args[0].add_attribute('nocapture')
+ fn.args[1].add_attribute('nocapture')
+ fn.return_value.add_attribute("noalias")
+ return self.builder.call(fn, [data, pyobj])
+
+ def nrt_meminfo_as_pyobject(self, miptr):
+ mod = self.builder.module
+ fnty = ir.FunctionType(
+ self.pyobj,
+ [cgutils.voidptr_t]
+ )
+ fn = cgutils.get_or_insert_function(
+ mod,
+ fnty,
+ 'NRT_meminfo_as_pyobject',
+ )
+ fn.return_value.add_attribute("noalias")
+ return self.builder.call(fn, [miptr])
+
+ def nrt_meminfo_from_pyobject(self, miobj):
+ mod = self.builder.module
+ fnty = ir.FunctionType(
+ cgutils.voidptr_t,
+ [self.pyobj]
+ )
+ fn = cgutils.get_or_insert_function(
+ mod,
+ fnty,
+ 'NRT_meminfo_from_pyobject',
+ )
+ fn.return_value.add_attribute("noalias")
+ return self.builder.call(fn, [miobj])
+
+ def nrt_adapt_ndarray_from_python(self, ary, ptr):
+ assert self.context.enable_nrt
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.voidptr])
+ fn = self._get_function(fnty, name="NRT_adapt_ndarray_from_python")
+ fn.args[0].add_attribute('nocapture')
+ fn.args[1].add_attribute('nocapture')
+ return self.builder.call(fn, (ary, ptr))
+
+ def nrt_adapt_buffer_from_python(self, buf, ptr):
+ assert self.context.enable_nrt
+ fnty = ir.FunctionType(ir.VoidType(), [ir.PointerType(self.py_buffer_t),
+ self.voidptr])
+ fn = self._get_function(fnty, name="NRT_adapt_buffer_from_python")
+ fn.args[0].add_attribute('nocapture')
+ fn.args[1].add_attribute('nocapture')
+ return self.builder.call(fn, (buf, ptr))
+
+ # ------ utils -----
+
+ def _get_function(self, fnty, name):
+ return cgutils.get_or_insert_function(self.module, fnty, name)
+
+ def alloca_obj(self):
+ return self.builder.alloca(self.pyobj)
+
+ def alloca_buffer(self):
+ """
+ Return a pointer to a stack-allocated, zero-initialized Py_buffer.
+ """
+ # Treat the buffer as an opaque array of bytes
+ ptr = cgutils.alloca_once_value(self.builder,
+ Constant(self.py_buffer_t, None))
+ return ptr
+
+ @contextlib.contextmanager
+ def if_object_ok(self, obj):
+ with cgutils.if_likely(self.builder,
+ cgutils.is_not_null(self.builder, obj)):
+ yield
+
+ def print_object(self, obj):
+ strobj = self.object_str(obj)
+ cstr = self.string_as_string(strobj)
+ fmt = self.context.insert_const_string(self.module, "%s")
+ self.sys_write_stdout(fmt, cstr)
+ self.decref(strobj)
+
+ def print_string(self, text):
+ fmt = self.context.insert_const_string(self.module, text)
+ self.sys_write_stdout(fmt)
+
+ def get_null_object(self):
+ return Constant(self.pyobj, None)
+
+ def return_none(self):
+ none = self.make_none()
+ self.builder.ret(none)
+
+ def list_pack(self, items):
+ n = len(items)
+ seq = self.list_new(self.context.get_constant(types.intp, n))
+ with self.if_object_ok(seq):
+ for i in range(n):
+ idx = self.context.get_constant(types.intp, i)
+ self.incref(items[i])
+ self.list_setitem(seq, idx, items[i])
+ return seq
+
+ def unserialize(self, structptr):
+ """
+ Unserialize some data. *structptr* should be a pointer to
+ a {i8* data, i32 length, i8* hashbuf, i8* func_ptr, i32 alloc_flag}
+ structure.
+ """
+ fnty = ir.FunctionType(self.pyobj,
+ (self.voidptr, ir.IntType(32), self.voidptr))
+ fn = self._get_function(fnty, name="numba_unpickle")
+ ptr = self.builder.extract_value(self.builder.load(structptr), 0)
+ n = self.builder.extract_value(self.builder.load(structptr), 1)
+ hashed = self.builder.extract_value(self.builder.load(structptr), 2)
+ return self.builder.call(fn, (ptr, n, hashed))
+
+ def build_dynamic_excinfo_struct(self, struct_gv, exc_args):
+ """
+ Serialize some data at runtime. Returns a pointer to a python tuple
+ (bytes_data, hash) where the first element is the serialized data as
+ bytes and the second its hash.
+ """
+ fnty = ir.FunctionType(self.pyobj, (self.pyobj, self.pyobj))
+ fn = self._get_function(fnty, name="numba_runtime_build_excinfo_struct")
+ return self.builder.call(fn, (struct_gv, exc_args))
+
+ def serialize_uncached(self, obj):
+ """
+ Same as serialize_object(), but don't create a global variable,
+ simply return a literal for structure:
+ {i8* data, i32 length, i8* hashbuf, i8* func_ptr, i32 alloc_flag}
+ """
+ # First make the array constant
+ data = serialize.dumps(obj)
+ assert len(data) < 2**31
+ name = ".const.pickledata.%s" % (id(obj) if config.DIFF_IR == 0 else "DIFF_IR")
+ bdata = cgutils.make_bytearray(data)
+ # Make SHA1 hash on the pickled content
+ # NOTE: update buffer size in numba_unpickle() when changing the
+ # hash algorithm.
+ hashed = cgutils.make_bytearray(hashlib.sha1(data).digest())
+ arr = self.context.insert_unique_const(self.module, name, bdata)
+ hasharr = self.context.insert_unique_const(
+ self.module, f"{name}.sha1", hashed,
+ )
+ # Then populate the structure constant
+ struct = Constant.literal_struct([
+ arr.bitcast(self.voidptr),
+ Constant(ir.IntType(32), arr.type.pointee.count),
+ hasharr.bitcast(self.voidptr),
+ cgutils.get_null_value(self.voidptr),
+ Constant(ir.IntType(32), 0),
+ ])
+ return struct
+
+ def serialize_object(self, obj):
+ """
+ Serialize the given object in the bitcode, and return it
+ as a pointer to a
+ {i8* data, i32 length, i8* hashbuf, i8* fn_ptr, i32 alloc_flag},
+ structure constant (suitable for passing to unserialize()).
+ """
+ try:
+ gv = self.module.__serialized[obj]
+ except KeyError:
+ struct = self.serialize_uncached(obj)
+ name = ".const.picklebuf.%s" % (id(obj) if config.DIFF_IR == 0 else "DIFF_IR")
+ gv = self.context.insert_unique_const(self.module, name, struct)
+ # Make the id() (and hence the name) unique while populating the module.
+ self.module.__serialized[obj] = gv
+ return gv
+
+ def c_api_error(self):
+ return cgutils.is_not_null(self.builder, self.err_occurred())
+
+ def to_native_value(self, typ, obj):
+ """
+ Unbox the Python object as the given Numba type.
+ A NativeValue instance is returned.
+ """
+ from numba.core.boxing import unbox_unsupported
+
+ impl = _unboxers.lookup(typ.__class__, unbox_unsupported)
+ c = _UnboxContext(self.context, self.builder, self)
+ return impl(typ, obj, c)
+
+ def from_native_return(self, typ, val, env_manager):
+ assert not isinstance(typ, types.Optional), "callconv should have " \
+ "prevented the return of " \
+ "optional value"
+ out = self.from_native_value(typ, val, env_manager)
+ return out
+
+ def from_native_value(self, typ, val, env_manager=None):
+ """
+ Box the native value of the given Numba type. A Python object
+ pointer is returned (NULL if an error occurred).
+ This method steals any native (NRT) reference embedded in *val*.
+ """
+ from numba.core.boxing import box_unsupported
+
+ impl = _boxers.lookup(typ.__class__, box_unsupported)
+
+ c = _BoxContext(self.context, self.builder, self, env_manager)
+ return impl(typ, val, c)
+
+ def reflect_native_value(self, typ, val, env_manager=None):
+ """
+ Reflect the native value onto its Python original, if any.
+ An error bit (as an LLVM value) is returned.
+ """
+ impl = _reflectors.lookup(typ.__class__)
+ if impl is None:
+ # Reflection isn't needed for most types
+ return cgutils.false_bit
+
+ is_error = cgutils.alloca_once_value(self.builder, cgutils.false_bit)
+ c = _ReflectContext(self.context, self.builder, self, env_manager,
+ is_error)
+ impl(typ, val, c)
+ return self.builder.load(c.is_error)
+
+ def to_native_generator(self, obj, typ):
+ """
+ Extract the generator structure pointer from a generator *obj*
+ (a _dynfunc.Generator instance).
+ """
+ gen_ptr_ty = ir.PointerType(self.context.get_data_type(typ))
+ value = self.context.get_generator_state(self.builder, obj, gen_ptr_ty)
+ return NativeValue(value)
+
+ def from_native_generator(self, val, typ, env=None):
+ """
+ Make a Numba generator (a _dynfunc.Generator instance) from a
+ generator structure pointer *val*.
+ *env* is an optional _dynfunc.Environment instance to be wrapped
+ in the generator.
+ """
+ llty = self.context.get_data_type(typ)
+ assert not llty.is_pointer
+ gen_struct_size = self.context.get_abi_sizeof(llty)
+
+ gendesc = self.context.get_generator_desc(typ)
+
+ # This is the PyCFunctionWithKeywords generated by PyCallWrapper
+ genfnty = ir.FunctionType(self.pyobj, [self.pyobj, self.pyobj, self.pyobj])
+ genfn = self._get_function(genfnty, name=gendesc.llvm_cpython_wrapper_name)
+
+ # This is the raw finalizer generated by _lower_generator_finalize_func()
+ finalizerty = ir.FunctionType(ir.VoidType(), [self.voidptr])
+ if typ.has_finalizer:
+ finalizer = self._get_function(finalizerty, name=gendesc.llvm_finalizer_name)
+ else:
+ finalizer = Constant(ir.PointerType(finalizerty), None)
+
+ # PyObject *numba_make_generator(state_size, initial_state, nextfunc, finalizer, env)
+ fnty = ir.FunctionType(self.pyobj, [self.py_ssize_t,
+ self.voidptr,
+ ir.PointerType(genfnty),
+ ir.PointerType(finalizerty),
+ self.voidptr])
+ fn = self._get_function(fnty, name="numba_make_generator")
+
+ state_size = Constant(self.py_ssize_t, gen_struct_size)
+ initial_state = self.builder.bitcast(val, self.voidptr)
+ if env is None:
+ env = self.get_null_object()
+ env = self.builder.bitcast(env, self.voidptr)
+
+ return self.builder.call(fn,
+ (state_size, initial_state, genfn, finalizer, env))
+
+ def numba_array_adaptor(self, ary, ptr):
+ assert not self.context.enable_nrt
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, self.voidptr])
+ fn = self._get_function(fnty, name="numba_adapt_ndarray")
+ fn.args[0].add_attribute('nocapture')
+ fn.args[1].add_attribute('nocapture')
+ return self.builder.call(fn, (ary, ptr))
+
+ def numba_buffer_adaptor(self, buf, ptr):
+ fnty = ir.FunctionType(ir.VoidType(),
+ [ir.PointerType(self.py_buffer_t), self.voidptr])
+ fn = self._get_function(fnty, name="numba_adapt_buffer")
+ fn.args[0].add_attribute('nocapture')
+ fn.args[1].add_attribute('nocapture')
+ return self.builder.call(fn, (buf, ptr))
+
+ def complex_adaptor(self, cobj, cmplx):
+ fnty = ir.FunctionType(ir.IntType(32), [self.pyobj, cmplx.type])
+ fn = self._get_function(fnty, name="numba_complex_adaptor")
+ return self.builder.call(fn, [cobj, cmplx])
+
+ def extract_record_data(self, obj, pbuf):
+ fnty = ir.FunctionType(self.voidptr,
+ [self.pyobj, ir.PointerType(self.py_buffer_t)])
+ fn = self._get_function(fnty, name="numba_extract_record_data")
+ return self.builder.call(fn, [obj, pbuf])
+
+ def get_buffer(self, obj, pbuf):
+ fnty = ir.FunctionType(ir.IntType(32),
+ [self.pyobj, ir.PointerType(self.py_buffer_t)])
+ fn = self._get_function(fnty, name="numba_get_buffer")
+ return self.builder.call(fn, [obj, pbuf])
+
+ def release_buffer(self, pbuf):
+ fnty = ir.FunctionType(ir.VoidType(), [ir.PointerType(self.py_buffer_t)])
+ fn = self._get_function(fnty, name="numba_release_buffer")
+ return self.builder.call(fn, [pbuf])
+
+ def extract_np_datetime(self, obj):
+ fnty = ir.FunctionType(ir.IntType(64), [self.pyobj])
+ fn = self._get_function(fnty, name="numba_extract_np_datetime")
+ return self.builder.call(fn, [obj])
+
+ def extract_np_timedelta(self, obj):
+ fnty = ir.FunctionType(ir.IntType(64), [self.pyobj])
+ fn = self._get_function(fnty, name="numba_extract_np_timedelta")
+ return self.builder.call(fn, [obj])
+
+ def create_np_datetime(self, val, unit_code):
+ unit_code = Constant(ir.IntType(32), int(unit_code))
+ fnty = ir.FunctionType(self.pyobj, [ir.IntType(64), ir.IntType(32)])
+ fn = self._get_function(fnty, name="numba_create_np_datetime")
+ return self.builder.call(fn, [val, unit_code])
+
+ def create_np_timedelta(self, val, unit_code):
+ unit_code = Constant(ir.IntType(32), int(unit_code))
+ fnty = ir.FunctionType(self.pyobj, [ir.IntType(64), ir.IntType(32)])
+ fn = self._get_function(fnty, name="numba_create_np_timedelta")
+ return self.builder.call(fn, [val, unit_code])
+
+ def recreate_record(self, pdata, size, dtype, env_manager):
+ fnty = ir.FunctionType(self.pyobj, [ir.PointerType(ir.IntType(8)),
+ ir.IntType(32), self.pyobj])
+ fn = self._get_function(fnty, name="numba_recreate_record")
+ dtypeaddr = env_manager.read_const(env_manager.add_const(dtype))
+ return self.builder.call(fn, [pdata, size, dtypeaddr])
+
+ def string_from_constant_string(self, string):
+ cstr = self.context.insert_const_string(self.module, string)
+ sz = self.context.get_constant(types.intp, len(string))
+ return self.string_from_string_and_size(cstr, sz)
+
+ def call_jit_code(self, func, sig, args):
+ """Calls into Numba jitted code and propagate error using the Python
+ calling convention.
+
+ Parameters
+ ----------
+ func : function
+ The Python function to be compiled. This function is compiled
+ in nopython-mode.
+ sig : numba.typing.Signature
+ The function signature for *func*.
+ args : Sequence[llvmlite.binding.Value]
+ LLVM values to use as arguments.
+
+ Returns
+ -------
+ (is_error, res) : 2-tuple of llvmlite.binding.Value.
+ is_error : true iff *func* raised an exception.
+ res : Returned value from *func* iff *is_error* is false.
+
+ If *is_error* is true, this method will adapt the nopython exception
+ into a Python exception. Caller should return NULL to Python to
+ indicate an error.
+ """
+ # Compile *func*
+ builder = self.builder
+ cres = self.context.compile_subroutine(builder, func, sig)
+ got_retty = cres.signature.return_type
+ retty = sig.return_type
+ if got_retty != retty:
+ # This error indicates an error in *func* or the caller of this
+ # method.
+ raise errors.LoweringError(
+ f'mismatching signature {got_retty} != {retty}.\n'
+ )
+ # Call into *func*
+ status, res = self.context.call_internal_no_propagate(
+ builder, cres.fndesc, sig, args,
+ )
+ # Post-call handling for *func*
+ is_error_ptr = cgutils.alloca_once(builder, cgutils.bool_t, zfill=True)
+ res_type = self.context.get_value_type(sig.return_type)
+ res_ptr = cgutils.alloca_once(builder, res_type, zfill=True)
+
+ # Handle error and adapt the nopython exception into cpython exception
+ with builder.if_else(status.is_error) as (has_err, no_err):
+ with has_err:
+ builder.store(status.is_error, is_error_ptr)
+ # Set error state in the Python interpreter
+ self.context.call_conv.raise_error(builder, self, status)
+ with no_err:
+ # Handle returned value
+ res = imputils.fix_returning_optional(
+ self.context, builder, sig, status, res,
+ )
+ builder.store(res, res_ptr)
+
+ is_error = builder.load(is_error_ptr)
+ res = builder.load(res_ptr)
+ return is_error, res
+
+
+class ObjModeUtils:
+ """Internal utils for calling objmode dispatcher from within NPM code.
+ """
+ def __init__(self, pyapi):
+ self.pyapi = pyapi
+
+ def load_dispatcher(self, fnty, argtypes):
+ builder = self.pyapi.builder
+ tyctx = self.pyapi.context
+ m = builder.module
+
+ # Add a global variable to cache the objmode dispatcher
+ gv = ir.GlobalVariable(
+ m, self.pyapi.pyobj,
+ name=m.get_unique_name("cached_objmode_dispatcher"),
+ )
+ gv.initializer = gv.type.pointee(None)
+ gv.linkage = 'internal'
+
+ # Make a basic-block to common exit
+ bb_end = builder.append_basic_block("bb_end")
+
+ if serialize.is_serialiable(fnty.dispatcher):
+ serialized_dispatcher = self.pyapi.serialize_object(
+ (fnty.dispatcher, tuple(argtypes)),
+ )
+ compile_args = self.pyapi.unserialize(serialized_dispatcher)
+ # unserialize (unpickling) can fail
+ failed_unser = cgutils.is_null(builder, compile_args)
+ with builder.if_then(failed_unser):
+ # early exit. `gv` is still null.
+ builder.branch(bb_end)
+
+ cached = builder.load(gv)
+ with builder.if_then(cgutils.is_null(builder, cached)):
+ if serialize.is_serialiable(fnty.dispatcher):
+ cls = type(self)
+ compiler = self.pyapi.unserialize(
+ self.pyapi.serialize_object(cls._call_objmode_dispatcher)
+ )
+ callee = self.pyapi.call_function_objargs(
+ compiler, [compile_args],
+ )
+ # Clean up
+ self.pyapi.decref(compiler)
+ self.pyapi.decref(compile_args)
+ else:
+ entry_pt = fnty.dispatcher.compile(tuple(argtypes))
+ callee = tyctx.add_dynamic_addr(
+ builder, id(entry_pt), info="with_objectmode",
+ )
+ # Incref the dispatcher and cache it
+ self.pyapi.incref(callee)
+ builder.store(callee, gv)
+ # Jump to the exit block
+ builder.branch(bb_end)
+ # Define the exit block
+ builder.position_at_end(bb_end)
+ callee = builder.load(gv)
+ return callee
+
+ @staticmethod
+ def _call_objmode_dispatcher(compile_args):
+ dispatcher, argtypes = compile_args
+ entrypt = dispatcher.compile(argtypes)
+ return entrypt
diff --git a/venv/lib/python3.10/site-packages/numba/core/registry.py b/venv/lib/python3.10/site-packages/numba/core/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..14f23aae7072b9709d9f0b2b99252f1711bf8ed9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/registry.py
@@ -0,0 +1,84 @@
+import contextlib
+#from functools import cached_property
+from numba.core.utils import threadsafe_cached_property as cached_property
+
+from numba.core.descriptors import TargetDescriptor
+from numba.core import utils, typing, dispatcher, cpu
+
+# -----------------------------------------------------------------------------
+# Default CPU target descriptors
+
+
+class CPUTarget(TargetDescriptor):
+ options = cpu.CPUTargetOptions
+
+ @cached_property
+ def _toplevel_target_context(self):
+ # Lazily-initialized top-level target context, for all threads
+ return cpu.CPUContext(self.typing_context, self._target_name)
+
+ @cached_property
+ def _toplevel_typing_context(self):
+ # Lazily-initialized top-level typing context, for all threads
+ return typing.Context()
+
+ @property
+ def target_context(self):
+ """
+ The target context for CPU targets.
+ """
+ return self._toplevel_target_context
+
+ @property
+ def typing_context(self):
+ """
+ The typing context for CPU targets.
+ """
+ return self._toplevel_typing_context
+
+
+# The global CPU target
+cpu_target = CPUTarget('cpu')
+
+
+class CPUDispatcher(dispatcher.Dispatcher):
+ targetdescr = cpu_target
+
+
+class DelayedRegistry(utils.UniqueDict):
+ """
+ A unique dictionary but with deferred initialisation of the values.
+
+ Attributes
+ ----------
+ ondemand:
+
+ A dictionary of key -> value, where value is executed
+ the first time it is is used. It is used for part of a deferred
+ initialization strategy.
+ """
+ def __init__(self, *args, **kws):
+ self.ondemand = utils.UniqueDict()
+ self.key_type = kws.pop('key_type', None)
+ self.value_type = kws.pop('value_type', None)
+ self._type_check = self.key_type or self.value_type
+ super(DelayedRegistry, self).__init__(*args, **kws)
+
+ def __getitem__(self, item):
+ if item in self.ondemand:
+ self[item] = self.ondemand[item]()
+ del self.ondemand[item]
+ return super(DelayedRegistry, self).__getitem__(item)
+
+ def __setitem__(self, key, value):
+ if self._type_check:
+ def check(x, ty_x):
+ if isinstance(ty_x, type):
+ assert ty_x in x.__mro__, (x, ty_x)
+ else:
+ assert isinstance(x, ty_x), (x, ty_x)
+ if self.key_type is not None:
+ check(key, self.key_type)
+ if self.value_type is not None:
+ check(value, self.value_type)
+ return super(DelayedRegistry, self).__setitem__(key, value)
diff --git a/venv/lib/python3.10/site-packages/numba/core/removerefctpass.py b/venv/lib/python3.10/site-packages/numba/core/removerefctpass.py
new file mode 100644
index 0000000000000000000000000000000000000000..98c04869a0bc5988dc936b920340a43ea06b438c
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/removerefctpass.py
@@ -0,0 +1,120 @@
+"""
+Implement a rewrite pass on a LLVM module to remove unnecessary
+refcount operations.
+"""
+
+from llvmlite.ir.transforms import CallVisitor
+
+from numba.core import types
+
+
+class _MarkNrtCallVisitor(CallVisitor):
+ """
+ A pass to mark all NRT_incref and NRT_decref.
+ """
+ def __init__(self):
+ self.marked = set()
+
+ def visit_Call(self, instr):
+ if getattr(instr.callee, 'name', '') in _accepted_nrtfns:
+ self.marked.add(instr)
+
+
+def _rewrite_function(function):
+ # Mark NRT usage
+ markpass = _MarkNrtCallVisitor()
+ markpass.visit_Function(function)
+ # Remove NRT usage
+ for bb in function.basic_blocks:
+ for inst in list(bb.instructions):
+ if inst in markpass.marked:
+ bb.instructions.remove(inst)
+
+
+_accepted_nrtfns = 'NRT_incref', 'NRT_decref'
+
+
+def _legalize(module, dmm, fndesc):
+ """
+ Legalize the code in the module.
+ Returns True if the module is legal for the rewrite pass that removes
+ unnecessary refcounts.
+ """
+
+ def valid_output(ty):
+ """
+ Valid output are any type that does not need refcount
+ """
+ model = dmm[ty]
+ return not model.contains_nrt_meminfo()
+
+ def valid_input(ty):
+ """
+ Valid input are any type that does not need refcount except Array.
+ """
+ return valid_output(ty) or isinstance(ty, types.Array)
+
+
+ # Ensure no reference to function marked as
+ # "numba_args_may_always_need_nrt"
+ try:
+ nmd = module.get_named_metadata("numba_args_may_always_need_nrt")
+ except KeyError:
+ # Nothing marked
+ pass
+ else:
+ # Has functions marked as "numba_args_may_always_need_nrt"
+ if len(nmd.operands) > 0:
+ # The pass is illegal for this compilation unit.
+ return False
+
+ # More legalization base on function type
+ argtypes = fndesc.argtypes
+ restype = fndesc.restype
+ calltypes = fndesc.calltypes
+
+ # Legalize function arguments
+ for argty in argtypes:
+ if not valid_input(argty):
+ return False
+
+ # Legalize function return
+ if not valid_output(restype):
+ return False
+
+ # Legalize all called functions
+ for callty in calltypes.values():
+ if callty is not None and not valid_output(callty.return_type):
+ return False
+
+ # Ensure no allocation
+ for fn in module.functions:
+ if fn.name.startswith("NRT_"):
+ if fn.name not in _accepted_nrtfns:
+ return False
+
+ return True
+
+
+def remove_unnecessary_nrt_usage(function, context, fndesc):
+ """
+ Remove unnecessary NRT incref/decref in the given LLVM function.
+ It uses highlevel type info to determine if the function does not need NRT.
+ Such a function does not:
+
+ - return array object(s);
+ - take arguments that need refcounting except array;
+ - call function(s) that return refcounted object.
+
+ In effect, the function will not capture or create references that extend
+ the lifetime of any refcounted objects beyond the lifetime of the function.
+
+ The rewrite is performed in place.
+ If rewrite has happened, this function returns True, otherwise, it returns False.
+ """
+ dmm = context.data_model_manager
+ if _legalize(function.module, dmm, fndesc):
+ _rewrite_function(function)
+ return True
+ else:
+ return False
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__init__.py b/venv/lib/python3.10/site-packages/numba/core/rewrites/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..61f55a8ecde8df1f3f8fef4533a9fdff6762b45c
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/rewrites/__init__.py
@@ -0,0 +1,8 @@
+"""
+A subpackage hosting Numba IR rewrite passes.
+"""
+
+from .registry import register_rewrite, rewrite_registry, Rewrite
+# Register various built-in rewrite passes
+from numba.core.rewrites import (static_getitem, static_raise, static_binop,
+ ir_print)
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d28d5c2ba5f9173d075aded8444df1a51ce9ef40
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/ir_print.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/ir_print.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..973c988a083aa9a06792f7c8590b96de0d330881
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/ir_print.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/registry.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/registry.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d5c77c69042e8d0cf9a7a742cedfaf3849a5cba
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/registry.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_binop.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_binop.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10cb1b9e5aa5a077747ba8ea73e4dc0b78672c1a
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_binop.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_getitem.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_getitem.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d239cf62b7f10805d1aacdc8c4ca18d83e04775
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_getitem.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_raise.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_raise.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3389159e7e8c8392148c5910a335d248ba26e63f
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/rewrites/__pycache__/static_raise.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/ir_print.py b/venv/lib/python3.10/site-packages/numba/core/rewrites/ir_print.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d678381bb18ab697d5c1fceb4c12e8cae18e342
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/rewrites/ir_print.py
@@ -0,0 +1,82 @@
+from numba.core import errors, ir
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class RewritePrintCalls(Rewrite):
+ """
+ Rewrite calls to the print() global function to dedicated IR print() nodes.
+ """
+
+ def match(self, func_ir, block, typemap, calltypes):
+ self.prints = prints = {}
+ self.block = block
+ # Find all assignments with a right-hand print() call
+ for inst in block.find_insts(ir.Assign):
+ if isinstance(inst.value, ir.Expr) and inst.value.op == 'call':
+ expr = inst.value
+ try:
+ callee = func_ir.infer_constant(expr.func)
+ except errors.ConstantInferenceError:
+ continue
+ if callee is print:
+ if expr.kws:
+ # Only positional args are supported
+ msg = ("Numba's print() function implementation does not "
+ "support keyword arguments.")
+ raise errors.UnsupportedError(msg, inst.loc)
+ prints[inst] = expr
+ return len(prints) > 0
+
+ def apply(self):
+ """
+ Rewrite `var = call (...)` as a sequence of
+ `print(...)` and `var = const(None)`.
+ """
+ new_block = self.block.copy()
+ new_block.clear()
+ for inst in self.block.body:
+ if inst in self.prints:
+ expr = self.prints[inst]
+ print_node = ir.Print(args=expr.args, vararg=expr.vararg,
+ loc=expr.loc)
+ new_block.append(print_node)
+ assign_node = ir.Assign(value=ir.Const(None, loc=expr.loc),
+ target=inst.target,
+ loc=inst.loc)
+ new_block.append(assign_node)
+ else:
+ new_block.append(inst)
+ return new_block
+
+
+@register_rewrite('before-inference')
+class DetectConstPrintArguments(Rewrite):
+ """
+ Detect and store constant arguments to print() nodes.
+ """
+
+ def match(self, func_ir, block, typemap, calltypes):
+ self.consts = consts = {}
+ self.block = block
+ for inst in block.find_insts(ir.Print):
+ if inst.consts:
+ # Already rewritten
+ continue
+ for idx, var in enumerate(inst.args):
+ try:
+ const = func_ir.infer_constant(var)
+ except errors.ConstantInferenceError:
+ continue
+ consts.setdefault(inst, {})[idx] = const
+
+ return len(consts) > 0
+
+ def apply(self):
+ """
+ Store detected constant arguments on their nodes.
+ """
+ for inst in self.block.body:
+ if inst in self.consts:
+ inst.consts = self.consts[inst]
+ return self.block
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/registry.py b/venv/lib/python3.10/site-packages/numba/core/rewrites/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea22fc8e354940235089c208e091382ed6ec87de
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/rewrites/registry.py
@@ -0,0 +1,98 @@
+from collections import defaultdict
+
+from numba.core import config
+
+
+class Rewrite(object):
+ '''Defines the abstract base class for Numba rewrites.
+ '''
+
+ def __init__(self, state=None):
+ '''Constructor for the Rewrite class.
+ '''
+ pass
+
+ def match(self, func_ir, block, typemap, calltypes):
+ '''Overload this method to check an IR block for matching terms in the
+ rewrite.
+ '''
+ return False
+
+ def apply(self):
+ '''Overload this method to return a rewritten IR basic block when a
+ match has been found.
+ '''
+ raise NotImplementedError("Abstract Rewrite.apply() called!")
+
+
+class RewriteRegistry(object):
+ '''Defines a registry for Numba rewrites.
+ '''
+ _kinds = frozenset(['before-inference', 'after-inference'])
+
+ def __init__(self):
+ '''Constructor for the rewrite registry. Initializes the rewrites
+ member to an empty list.
+ '''
+ self.rewrites = defaultdict(list)
+
+ def register(self, kind):
+ """
+ Decorator adding a subclass of Rewrite to the registry for
+ the given *kind*.
+ """
+ if kind not in self._kinds:
+ raise KeyError("invalid kind %r" % (kind,))
+ def do_register(rewrite_cls):
+ if not issubclass(rewrite_cls, Rewrite):
+ raise TypeError('{0} is not a subclass of Rewrite'.format(
+ rewrite_cls))
+ self.rewrites[kind].append(rewrite_cls)
+ return rewrite_cls
+ return do_register
+
+ def apply(self, kind, state):
+ '''Given a pipeline and a dictionary of basic blocks, exhaustively
+ attempt to apply all registered rewrites to all basic blocks.
+ '''
+ assert kind in self._kinds
+ blocks = state.func_ir.blocks
+ old_blocks = blocks.copy()
+ for rewrite_cls in self.rewrites[kind]:
+ # Exhaustively apply a rewrite until it stops matching.
+ rewrite = rewrite_cls(state)
+ work_list = list(blocks.items())
+ while work_list:
+ key, block = work_list.pop()
+ matches = rewrite.match(state.func_ir, block, state.typemap,
+ state.calltypes)
+ if matches:
+ if config.DEBUG or config.DUMP_IR:
+ print("_" * 70)
+ print("REWRITING (%s):" % rewrite_cls.__name__)
+ block.dump()
+ print("_" * 60)
+ new_block = rewrite.apply()
+ blocks[key] = new_block
+ work_list.append((key, new_block))
+ if config.DEBUG or config.DUMP_IR:
+ new_block.dump()
+ print("_" * 70)
+ # If any blocks were changed, perform a sanity check.
+ for key, block in blocks.items():
+ if block != old_blocks[key]:
+ block.verify()
+
+ # Some passes, e.g. _inline_const_arraycall are known to occasionally
+ # do invalid things WRT ir.Del, others, e.g. RewriteArrayExprs do valid
+ # things with ir.Del, but the placement is not optimal. The lines below
+ # fix-up the IR so that ref counts are valid and optimally placed,
+ # see #4093 for context. This has to be run here opposed to in
+ # apply() as the CFG needs computing so full IR is needed.
+ from numba.core import postproc
+ post_proc = postproc.PostProcessor(state.func_ir)
+ post_proc.run()
+
+
+rewrite_registry = RewriteRegistry()
+register_rewrite = rewrite_registry.register
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/static_binop.py b/venv/lib/python3.10/site-packages/numba/core/rewrites/static_binop.py
new file mode 100644
index 0000000000000000000000000000000000000000..33487a67549856c73d655cc1fc59a95eab941f6b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/rewrites/static_binop.py
@@ -0,0 +1,35 @@
+from numba.core import errors, ir
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class DetectStaticBinops(Rewrite):
+ """
+ Detect constant arguments to select binops.
+ """
+
+ # Those operators can benefit from a constant-inferred argument
+ rhs_operators = {'**'}
+
+ def match(self, func_ir, block, typemap, calltypes):
+ self.static_lhs = {}
+ self.static_rhs = {}
+ self.block = block
+ # Find binop expressions with a constant lhs or rhs
+ for expr in block.find_exprs(op='binop'):
+ try:
+ if (expr.fn in self.rhs_operators
+ and expr.static_rhs is ir.UNDEFINED):
+ self.static_rhs[expr] = func_ir.infer_constant(expr.rhs)
+ except errors.ConstantInferenceError:
+ continue
+
+ return len(self.static_lhs) > 0 or len(self.static_rhs) > 0
+
+ def apply(self):
+ """
+ Store constant arguments that were detected in match().
+ """
+ for expr, rhs in self.static_rhs.items():
+ expr.static_rhs = rhs
+ return self.block
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/static_getitem.py b/venv/lib/python3.10/site-packages/numba/core/rewrites/static_getitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..56343d0eac93cef756834d22c76780e228398a7d
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/rewrites/static_getitem.py
@@ -0,0 +1,175 @@
+from numba.core import errors, ir, types
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class RewriteConstGetitems(Rewrite):
+ """
+ Rewrite IR expressions of the kind `getitem(value=arr, index=$constXX)`
+ where `$constXX` is a known constant as
+ `static_getitem(value=arr, index=)`.
+ """
+
+ def match(self, func_ir, block, typemap, calltypes):
+ self.getitems = getitems = {}
+ self.block = block
+ # Detect all getitem expressions and find which ones can be
+ # rewritten
+ for expr in block.find_exprs(op='getitem'):
+ if expr.op == 'getitem':
+ try:
+ const = func_ir.infer_constant(expr.index)
+ except errors.ConstantInferenceError:
+ continue
+ getitems[expr] = const
+
+ return len(getitems) > 0
+
+ def apply(self):
+ """
+ Rewrite all matching getitems as static_getitems.
+ """
+ new_block = self.block.copy()
+ new_block.clear()
+ for inst in self.block.body:
+ if isinstance(inst, ir.Assign):
+ expr = inst.value
+ if expr in self.getitems:
+ const = self.getitems[expr]
+ new_expr = ir.Expr.static_getitem(value=expr.value,
+ index=const,
+ index_var=expr.index,
+ loc=expr.loc)
+ inst = ir.Assign(value=new_expr, target=inst.target,
+ loc=inst.loc)
+ new_block.append(inst)
+ return new_block
+
+
+@register_rewrite('after-inference')
+class RewriteStringLiteralGetitems(Rewrite):
+ """
+ Rewrite IR expressions of the kind `getitem(value=arr, index=$XX)`
+ where `$XX` is a StringLiteral value as
+ `static_getitem(value=arr, index=)`.
+ """
+
+ def match(self, func_ir, block, typemap, calltypes):
+ """
+ Detect all getitem expressions and find which ones have
+ string literal indexes
+ """
+ self.getitems = getitems = {}
+ self.block = block
+ self.calltypes = calltypes
+ for expr in block.find_exprs(op='getitem'):
+ if expr.op == 'getitem':
+ index_ty = typemap[expr.index.name]
+ if isinstance(index_ty, types.StringLiteral):
+ getitems[expr] = (expr.index, index_ty.literal_value)
+
+ return len(getitems) > 0
+
+ def apply(self):
+ """
+ Rewrite all matching getitems as static_getitems where the index
+ is the literal value of the string.
+ """
+ new_block = ir.Block(self.block.scope, self.block.loc)
+ for inst in self.block.body:
+ if isinstance(inst, ir.Assign):
+ expr = inst.value
+ if expr in self.getitems:
+ const, lit_val = self.getitems[expr]
+ new_expr = ir.Expr.static_getitem(value=expr.value,
+ index=lit_val,
+ index_var=expr.index,
+ loc=expr.loc)
+ self.calltypes[new_expr] = self.calltypes[expr]
+ inst = ir.Assign(value=new_expr, target=inst.target,
+ loc=inst.loc)
+ new_block.append(inst)
+ return new_block
+
+
+@register_rewrite('after-inference')
+class RewriteStringLiteralSetitems(Rewrite):
+ """
+ Rewrite IR expressions of the kind `setitem(value=arr, index=$XX, value=)`
+ where `$XX` is a StringLiteral value as
+ `static_setitem(value=arr, index=, value=)`.
+ """
+
+ def match(self, func_ir, block, typemap, calltypes):
+ """
+ Detect all setitem expressions and find which ones have
+ string literal indexes
+ """
+ self.setitems = setitems = {}
+ self.block = block
+ self.calltypes = calltypes
+ for inst in block.find_insts(ir.SetItem):
+ index_ty = typemap[inst.index.name]
+ if isinstance(index_ty, types.StringLiteral):
+ setitems[inst] = (inst.index, index_ty.literal_value)
+
+ return len(setitems) > 0
+
+ def apply(self):
+ """
+ Rewrite all matching setitems as static_setitems where the index
+ is the literal value of the string.
+ """
+ new_block = ir.Block(self.block.scope, self.block.loc)
+ for inst in self.block.body:
+ if isinstance(inst, ir.SetItem):
+ if inst in self.setitems:
+ const, lit_val = self.setitems[inst]
+ new_inst = ir.StaticSetItem(target=inst.target,
+ index=lit_val,
+ index_var=inst.index,
+ value=inst.value,
+ loc=inst.loc)
+ self.calltypes[new_inst] = self.calltypes[inst]
+ inst = new_inst
+ new_block.append(inst)
+ return new_block
+
+
+@register_rewrite('before-inference')
+class RewriteConstSetitems(Rewrite):
+ """
+ Rewrite IR statements of the kind `setitem(target=arr, index=$constXX, ...)`
+ where `$constXX` is a known constant as
+ `static_setitem(target=arr, index=, ...)`.
+ """
+
+ def match(self, func_ir, block, typemap, calltypes):
+ self.setitems = setitems = {}
+ self.block = block
+ # Detect all setitem statements and find which ones can be
+ # rewritten
+ for inst in block.find_insts(ir.SetItem):
+ try:
+ const = func_ir.infer_constant(inst.index)
+ except errors.ConstantInferenceError:
+ continue
+ setitems[inst] = const
+
+ return len(setitems) > 0
+
+ def apply(self):
+ """
+ Rewrite all matching setitems as static_setitems.
+ """
+ new_block = self.block.copy()
+ new_block.clear()
+ for inst in self.block.body:
+ if inst in self.setitems:
+ const = self.setitems[inst]
+ new_inst = ir.StaticSetItem(inst.target, const,
+ inst.index, inst.value, inst.loc)
+ new_block.append(new_inst)
+ else:
+ new_block.append(inst)
+ return new_block
diff --git a/venv/lib/python3.10/site-packages/numba/core/rewrites/static_raise.py b/venv/lib/python3.10/site-packages/numba/core/rewrites/static_raise.py
new file mode 100644
index 0000000000000000000000000000000000000000..7527e571f026fcf0eef9c53645caa46a94b37f73
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/rewrites/static_raise.py
@@ -0,0 +1,93 @@
+from numba.core import errors, ir, consts
+from numba.core.rewrites import register_rewrite, Rewrite
+
+
+@register_rewrite('before-inference')
+class RewriteConstRaises(Rewrite):
+ """
+ Rewrite IR statements of the kind `raise(value)`
+ where `value` is the result of instantiating an exception with
+ constant arguments
+ into `static_raise(exception_type, constant args)`.
+
+ This allows lowering in nopython mode, where one can't instantiate
+ exception instances from runtime data.
+ """
+
+ def _is_exception_type(self, const):
+ return isinstance(const, type) and issubclass(const, Exception)
+
+ def _break_constant(self, const, loc):
+ """
+ Break down constant exception.
+ """
+ if isinstance(const, tuple): # it's a tuple(exception class, args)
+ if not self._is_exception_type(const[0]):
+ msg = "Encountered unsupported exception constant %r"
+ raise errors.UnsupportedError(msg % (const[0],), loc)
+ return const[0], tuple(const[1])
+ elif self._is_exception_type(const):
+ return const, None
+ else:
+ if isinstance(const, str):
+ msg = ("Directly raising a string constant as an exception is "
+ "not supported.")
+ else:
+ msg = "Encountered unsupported constant type used for exception"
+ raise errors.UnsupportedError(msg, loc)
+
+ def _try_infer_constant(self, func_ir, inst):
+ try:
+ return func_ir.infer_constant(inst.exception)
+ except consts.ConstantInferenceError:
+ # not a static exception
+ return None
+
+ def match(self, func_ir, block, typemap, calltypes):
+ self.raises = raises = {}
+ self.tryraises = tryraises = {}
+ self.block = block
+ # Detect all raise statements and find which ones can be
+ # rewritten
+ for inst in block.find_insts((ir.Raise, ir.TryRaise)):
+ if inst.exception is None:
+ # re-reraise
+ exc_type, exc_args = None, None
+ else:
+ # raise => find the definition site for
+ const = self._try_infer_constant(func_ir, inst)
+
+ # failure to infer constant indicates this isn't a static
+ # exception
+ if const is None:
+ continue
+
+ loc = inst.exception.loc
+ exc_type, exc_args = self._break_constant(const, loc)
+
+ if isinstance(inst, ir.Raise):
+ raises[inst] = exc_type, exc_args
+ elif isinstance(inst, ir.TryRaise):
+ tryraises[inst] = exc_type, exc_args
+ else:
+ raise ValueError('unexpected: {}'.format(type(inst)))
+ return (len(raises) + len(tryraises)) > 0
+
+ def apply(self):
+ """
+ Rewrite all matching setitems as static_setitems.
+ """
+ new_block = self.block.copy()
+ new_block.clear()
+ for inst in self.block.body:
+ if inst in self.raises:
+ exc_type, exc_args = self.raises[inst]
+ new_inst = ir.StaticRaise(exc_type, exc_args, inst.loc)
+ new_block.append(new_inst)
+ elif inst in self.tryraises:
+ exc_type, exc_args = self.tryraises[inst]
+ new_inst = ir.StaticTryRaise(exc_type, exc_args, inst.loc)
+ new_block.append(new_inst)
+ else:
+ new_block.append(inst)
+ return new_block
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/__init__.py b/venv/lib/python3.10/site-packages/numba/core/runtime/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5904700316933083c9996ee5e132c620f25014e0
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/__init__.py
@@ -0,0 +1 @@
+from .nrt import rtsys
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a4df4d82af3198af183c04e2837f35054bce3e2
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/context.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/context.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a56aaa5290d2fb31a3f57ef9bc85f342c33e85ba
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/context.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrt.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrt.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff2fc4ea5ab67fb5a852b165170819ab64166317
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrt.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrtdynmod.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrtdynmod.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ab9fdcf5303b5e64cbe447466baa89db1d1003f
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrtdynmod.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrtopt.cpython-310.pyc b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrtopt.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a9bdea6f2def2196e1971d6a956af380c2e1eab9
Binary files /dev/null and b/venv/lib/python3.10/site-packages/numba/core/runtime/__pycache__/nrtopt.cpython-310.pyc differ
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/_nrt_python.c b/venv/lib/python3.10/site-packages/numba/core/runtime/_nrt_python.c
new file mode 100644
index 0000000000000000000000000000000000000000..84d5886f439cab02e8167dd970fadee74ef46e5b
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/_nrt_python.c
@@ -0,0 +1,486 @@
+/*
+ * Definition of NRT functions for marshalling from / to Python objects.
+ * This module is included by _nrt_pythonmod.c and by pycc-compiled modules.
+ */
+
+#include "../../_pymodule.h"
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include
+#include
+
+#include "../../_arraystruct.h"
+#include "../../_numba_common.h"
+#include "nrt.h"
+
+
+/*
+ * Create a NRT MemInfo for data owned by a PyObject.
+ */
+
+static void
+pyobject_dtor(void *ptr, size_t size, void* info) {
+ PyGILState_STATE gstate;
+ PyObject *ownerobj = info;
+
+ gstate = PyGILState_Ensure(); /* ensure the GIL */
+ Py_DECREF(ownerobj); /* release the python object */
+ PyGILState_Release(gstate); /* release the GIL */
+}
+
+NUMBA_EXPORT_FUNC(NRT_MemInfo *)
+NRT_meminfo_new_from_pyobject(void *data, PyObject *ownerobj) {
+ size_t dummy_size = 0;
+ Py_INCREF(ownerobj);
+ return NRT_MemInfo_new(data, dummy_size, pyobject_dtor, ownerobj);
+}
+
+
+/*
+ * A Python object wrapping a NRT meminfo.
+ */
+
+typedef struct {
+ PyObject_HEAD
+ NRT_MemInfo *meminfo;
+} MemInfoObject;
+
+
+static
+int MemInfo_init(MemInfoObject *self, PyObject *args, PyObject *kwds) {
+ static char *keywords[] = {"ptr", NULL};
+ PyObject *raw_ptr_obj;
+ void *raw_ptr;
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", keywords, &raw_ptr_obj)) {
+ return -1;
+ }
+ raw_ptr = PyLong_AsVoidPtr(raw_ptr_obj);
+ NRT_Debug(nrt_debug_print("MemInfo_init self=%p raw_ptr=%p\n", self, raw_ptr));
+
+ if(PyErr_Occurred()) return -1;
+ self->meminfo = (NRT_MemInfo *)raw_ptr;
+ assert (NRT_MemInfo_refcount(self->meminfo) > 0 && "0 refcount");
+ return 0;
+}
+
+
+static int
+MemInfo_getbuffer(PyObject *exporter, Py_buffer *view, int flags) {
+ Py_ssize_t len;
+ void *buf;
+ int readonly = 0;
+
+ MemInfoObject *miobj = (MemInfoObject*)exporter;
+ NRT_MemInfo *mi = miobj->meminfo;
+
+ buf = NRT_MemInfo_data(mi);
+ len = NRT_MemInfo_size(mi);
+ return PyBuffer_FillInfo(view, exporter, buf, len, readonly, flags);
+}
+
+static PyBufferProcs MemInfo_bufferProcs = {MemInfo_getbuffer, NULL};
+
+static
+PyObject*
+MemInfo_acquire(MemInfoObject *self) {
+ NRT_MemInfo_acquire(self->meminfo);
+ Py_RETURN_NONE;
+}
+
+static
+PyObject*
+MemInfo_release(MemInfoObject *self) {
+ NRT_MemInfo_release(self->meminfo);
+ Py_RETURN_NONE;
+}
+
+static
+PyObject*
+MemInfo_get_data(MemInfoObject *self, void *closure) {
+ return PyLong_FromVoidPtr(NRT_MemInfo_data(self->meminfo));
+}
+
+static
+PyObject*
+MemInfo_get_refcount(MemInfoObject *self, void *closure) {
+ size_t refct = NRT_MemInfo_refcount(self->meminfo);
+ if ( refct == (size_t)-1 ) {
+ PyErr_SetString(PyExc_ValueError, "invalid MemInfo");
+ return NULL;
+ }
+ return PyLong_FromSize_t(refct);
+}
+
+static
+PyObject*
+MemInfo_get_external_allocator(MemInfoObject *self, void *closure) {
+ void *p = NRT_MemInfo_external_allocator(self->meminfo);
+ return PyLong_FromVoidPtr(p);
+}
+
+static
+PyObject*
+MemInfo_get_parent(MemInfoObject *self, void *closure) {
+ void *p = NRT_MemInfo_parent(self->meminfo);
+ if (p) {
+ Py_INCREF(p);
+ return (PyObject*)p;
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+}
+
+static void
+MemInfo_dealloc(MemInfoObject *self)
+{
+ NRT_MemInfo_release(self->meminfo);
+ Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyMethodDef MemInfo_methods[] = {
+ {"acquire", (PyCFunction)MemInfo_acquire, METH_NOARGS,
+ "Increment the reference count"
+ },
+ {"release", (PyCFunction)MemInfo_release, METH_NOARGS,
+ "Decrement the reference count"
+ },
+ {NULL} /* Sentinel */
+};
+
+
+static PyGetSetDef MemInfo_getsets[] = {
+ {"data",
+ (getter)MemInfo_get_data, NULL,
+ "Get the data pointer as an integer",
+ NULL},
+ {"refcount",
+ (getter)MemInfo_get_refcount, NULL,
+ "Get the refcount",
+ NULL},
+ {"external_allocator",
+ (getter)MemInfo_get_external_allocator, NULL,
+ "Get the external allocator",
+ NULL},
+ {"parent",
+ (getter)MemInfo_get_parent, NULL,
+ NULL},
+ {NULL} /* Sentinel */
+};
+
+
+static PyTypeObject MemInfoType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "_nrt_python._MemInfo", /* tp_name */
+ sizeof(MemInfoObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)MemInfo_dealloc, /* tp_dealloc */
+ 0, /* tp_vectorcall_offset */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_as_async */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ &MemInfo_bufferProcs, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ MemInfo_methods, /* tp_methods */
+ 0, /* tp_members */
+ MemInfo_getsets, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ (initproc)MemInfo_init, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /* tp_new */
+ 0, /* tp_free */
+ 0, /* tp_is_gc */
+ 0, /* tp_bases */
+ 0, /* tp_mro */
+ 0, /* tp_cache */
+ 0, /* tp_subclasses */
+ 0, /* tp_weaklist */
+ 0, /* tp_del */
+ 0, /* tp_version_tag */
+ 0, /* tp_finalize */
+ 0, /* tp_vectorcall */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+/* This was introduced first in 3.12
+ * https://github.com/python/cpython/issues/91051
+ */
+ 0, /* tp_watched */
+#endif
+
+/* WARNING: Do not remove this, only modify it! It is a version guard to
+ * act as a reminder to update this struct on Python version update! */
+#if (PY_MAJOR_VERSION == 3)
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
+#error "Python minor version is not supported."
+#endif
+#else
+#error "Python major version is not supported."
+#endif
+/* END WARNING*/
+};
+
+/*
+Return a MemInfo* as a MemInfoObject*
+The NRT reference to the MemInfo is borrowed.
+*/
+NUMBA_EXPORT_FUNC(MemInfoObject*)
+NRT_meminfo_as_pyobject(NRT_MemInfo *meminfo) {
+ MemInfoObject *mi;
+ PyObject *addr;
+
+ addr = PyLong_FromVoidPtr(meminfo);
+ if (!addr) return NULL;
+ mi = (MemInfoObject*)PyObject_CallFunctionObjArgs((PyObject *)&MemInfoType, addr, NULL);
+ Py_DECREF(addr);
+ if (!mi) return NULL;
+ return mi;
+}
+
+
+/*
+Return a MemInfo* from a MemInfoObject*
+A new reference is returned.
+*/
+NUMBA_EXPORT_FUNC(NRT_MemInfo*)
+NRT_meminfo_from_pyobject(MemInfoObject *miobj) {
+ NRT_MemInfo_acquire(miobj->meminfo);
+ return miobj->meminfo;
+}
+
+
+/*
+ * Array adaptor code
+ */
+
+NUMBA_EXPORT_FUNC(int)
+NRT_adapt_ndarray_from_python(PyObject *obj, arystruct_t* arystruct) {
+ PyArrayObject *ndary;
+ int i, ndim;
+ npy_intp *p;
+ void *data;
+
+ if (!PyArray_Check(obj)) {
+ return -1;
+ }
+
+ ndary = (PyArrayObject*)obj;
+ ndim = PyArray_NDIM(ndary);
+ data = PyArray_DATA(ndary);
+
+ arystruct->meminfo = NRT_meminfo_new_from_pyobject((void*)data, obj);
+ arystruct->data = data;
+ arystruct->nitems = PyArray_SIZE(ndary);
+ arystruct->itemsize = PyArray_ITEMSIZE(ndary);
+ arystruct->parent = obj;
+ p = arystruct->shape_and_strides;
+ for (i = 0; i < ndim; i++, p++) {
+ *p = PyArray_DIM(ndary, i);
+ }
+ for (i = 0; i < ndim; i++, p++) {
+ *p = PyArray_STRIDE(ndary, i);
+ }
+
+ NRT_Debug(nrt_debug_print("NRT_adapt_ndarray_from_python %p\n",
+ arystruct->meminfo));
+ return 0;
+}
+
+static
+PyObject* try_to_return_parent(arystruct_t *arystruct, int ndim,
+ PyArray_Descr *descr)
+{
+ int i;
+ PyArrayObject *array = (PyArrayObject *)arystruct->parent;
+
+ if (!PyArray_Check(arystruct->parent))
+ /* Parent is a generic buffer-providing object */
+ goto RETURN_ARRAY_COPY;
+
+ if (PyArray_DATA(array) != arystruct->data)
+ goto RETURN_ARRAY_COPY;
+
+ if (PyArray_NDIM(array) != ndim)
+ goto RETURN_ARRAY_COPY;
+
+ if (PyObject_RichCompareBool((PyObject *) PyArray_DESCR(array),
+ (PyObject *) descr, Py_EQ) <= 0)
+ goto RETURN_ARRAY_COPY;
+
+ for(i = 0; i < ndim; ++i) {
+ if (PyArray_DIMS(array)[i] != arystruct->shape_and_strides[i])
+ goto RETURN_ARRAY_COPY;
+ if (PyArray_STRIDES(array)[i] != arystruct->shape_and_strides[ndim + i])
+ goto RETURN_ARRAY_COPY;
+ }
+
+ /* Yes, it is the same array
+ Return new reference */
+ Py_INCREF((PyObject *)array);
+ return (PyObject *)array;
+
+RETURN_ARRAY_COPY:
+ return NULL;
+}
+
+/**
+ * This function is used during the boxing of ndarray type.
+ * `arystruct` is a structure containing essential information from the
+ * unboxed array.
+ * `retty` is the subtype of the NumPy PyArray_Type this function should return.
+ * This is related to `numba.core.types.Array.box_type`.
+ * `ndim` is the number of dimension of the array.
+ * `writeable` corresponds to the "writable" flag in NumPy ndarray.
+ * `descr` is the NumPy data type description.
+ *
+ * This function was renamed in 0.52.0 to specify that it acquires references.
+ * It used to steal the reference of the arystruct.
+ * Refer to https://github.com/numba/numba/pull/6446
+ */
+NUMBA_EXPORT_FUNC(PyObject *)
+NRT_adapt_ndarray_to_python_acqref(arystruct_t* arystruct, PyTypeObject *retty,
+ int ndim, int writeable, PyArray_Descr *descr)
+{
+ PyArrayObject *array;
+ MemInfoObject *miobj = NULL;
+ PyObject *args;
+ npy_intp *shape, *strides;
+ int flags = 0;
+
+ if (descr == NULL) {
+ PyErr_Format(PyExc_RuntimeError,
+ "In 'NRT_adapt_ndarray_to_python', 'descr' is NULL");
+ return NULL;
+ }
+
+ if (!NUMBA_PyArray_DescrCheck(descr)) {
+ PyErr_Format(PyExc_TypeError,
+ "expected dtype object, got '%.200s'",
+ Py_TYPE(descr)->tp_name);
+ return NULL;
+ }
+
+ if (arystruct->parent) {
+ PyObject *obj = try_to_return_parent(arystruct, ndim, descr);
+ if (obj) {
+ return obj;
+ }
+ }
+
+ if (arystruct->meminfo) {
+ /* wrap into MemInfoObject */
+ miobj = PyObject_New(MemInfoObject, &MemInfoType);
+ args = PyTuple_New(1);
+ /* SETITEM steals reference */
+ PyTuple_SET_ITEM(args, 0, PyLong_FromVoidPtr(arystruct->meminfo));
+ NRT_Debug(nrt_debug_print("NRT_adapt_ndarray_to_python arystruct->meminfo=%p\n", arystruct->meminfo));
+ /* Note: MemInfo_init() does not incref. This function steals the
+ * NRT reference, which we need to acquire.
+ */
+ NRT_Debug(nrt_debug_print("NRT_adapt_ndarray_to_python_acqref created MemInfo=%p\n", miobj));
+ NRT_MemInfo_acquire(arystruct->meminfo);
+ if (MemInfo_init(miobj, args, NULL)) {
+ NRT_Debug(nrt_debug_print("MemInfo_init failed.\n"));
+ return NULL;
+ }
+ Py_DECREF(args);
+ }
+
+ shape = arystruct->shape_and_strides;
+ strides = shape + ndim;
+ Py_INCREF((PyObject *) descr);
+ array = (PyArrayObject *) PyArray_NewFromDescr(retty, descr, ndim,
+ shape, strides, arystruct->data,
+ flags, (PyObject *) miobj);
+
+ if (array == NULL)
+ return NULL;
+
+ /* Set writable */
+#if NPY_API_VERSION >= 0x00000007
+ if (writeable) {
+ PyArray_ENABLEFLAGS(array, NPY_ARRAY_WRITEABLE);
+ }
+ else {
+ PyArray_CLEARFLAGS(array, NPY_ARRAY_WRITEABLE);
+ }
+#else
+ if (writeable) {
+ array->flags |= NPY_WRITEABLE;
+ }
+ else {
+ array->flags &= ~NPY_WRITEABLE;
+ }
+#endif
+
+ if (miobj) {
+ /* Set the MemInfoObject as the base object */
+#if NPY_API_VERSION >= 0x00000007
+ if (-1 == PyArray_SetBaseObject(array,
+ (PyObject *) miobj))
+ {
+ Py_DECREF(array);
+ Py_DECREF(miobj);
+ return NULL;
+ }
+#else
+ PyArray_BASE(array) = (PyObject *) miobj;
+#endif
+
+ }
+ return (PyObject *) array;
+}
+
+NUMBA_EXPORT_FUNC(void)
+NRT_adapt_buffer_from_python(Py_buffer *buf, arystruct_t *arystruct)
+{
+ int i;
+ npy_intp *p;
+
+ if (buf->obj) {
+ /* Allocate new MemInfo only if the buffer has a parent */
+ arystruct->meminfo = NRT_meminfo_new_from_pyobject((void*)buf->buf, buf->obj);
+ }
+ arystruct->data = buf->buf;
+ arystruct->itemsize = buf->itemsize;
+ arystruct->parent = buf->obj;
+ arystruct->nitems = 1;
+ p = arystruct->shape_and_strides;
+ for (i = 0; i < buf->ndim; i++, p++) {
+ *p = buf->shape[i];
+ arystruct->nitems *= buf->shape[i];
+ }
+ for (i = 0; i < buf->ndim; i++, p++) {
+ *p = buf->strides[i];
+ }
+}
+
+
+/* Initialization subroutines for modules including this source file */
+
+static int
+init_nrt_python_module(PyObject *module)
+{
+ MemInfoType.tp_new = PyType_GenericNew;
+ if (PyType_Ready(&MemInfoType))
+ return -1;
+ return 0;
+}
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/_nrt_pythonmod.c b/venv/lib/python3.10/site-packages/numba/core/runtime/_nrt_pythonmod.c
new file mode 100644
index 0000000000000000000000000000000000000000..19eb120fac011064c2c2e73ba8cdb6affc2fbf53
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/_nrt_pythonmod.c
@@ -0,0 +1,217 @@
+#define NUMBA_EXPORT_FUNC(_rettype) static _rettype
+#define NUMBA_EXPORT_DATA(_vartype) static _vartype
+
+#include "_nrt_python.c"
+
+static PyObject *
+memsys_shutdown(PyObject *self, PyObject *args) {
+ NRT_MemSys_shutdown();
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+memsys_use_cpython_allocator(PyObject *self, PyObject *args) {
+ NRT_MemSys_set_allocator(PyMem_RawMalloc,
+ PyMem_RawRealloc,
+ PyMem_RawFree);
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+memsys_get_stats_alloc(PyObject *self, PyObject *args) {
+ if(!NRT_MemSys_stats_enabled()) {
+ PyErr_SetString(PyExc_RuntimeError, "NRT stats are disabled.");
+ return NULL;
+ }
+ return PyLong_FromSize_t(NRT_MemSys_get_stats_alloc());
+}
+
+static PyObject *
+memsys_get_stats_free(PyObject *self, PyObject *args) {
+ if(!NRT_MemSys_stats_enabled()) {
+ PyErr_SetString(PyExc_RuntimeError, "NRT stats are disabled.");
+ return NULL;
+ }
+ return PyLong_FromSize_t(NRT_MemSys_get_stats_free());
+}
+
+static PyObject *
+memsys_get_stats_mi_alloc(PyObject *self, PyObject *args) {
+ if(!NRT_MemSys_stats_enabled()) {
+ PyErr_SetString(PyExc_RuntimeError, "NRT stats are disabled.");
+ return NULL;
+ }
+ return PyLong_FromSize_t(NRT_MemSys_get_stats_mi_alloc());
+}
+
+static PyObject *
+memsys_get_stats_mi_free(PyObject *self, PyObject *args) {
+ if(!NRT_MemSys_stats_enabled()) {
+ PyErr_SetString(PyExc_RuntimeError, "NRT stats are disabled.");
+ return NULL;
+ }
+ return PyLong_FromSize_t(NRT_MemSys_get_stats_mi_free());
+}
+
+static PyObject *
+memsys_stats_enabled(PyObject *self, PyObject *args) {
+ if (NRT_MemSys_stats_enabled()) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+}
+
+static PyObject *
+memsys_enable_stats(PyObject *self, PyObject *args) {
+ NRT_MemSys_enable_stats();
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+memsys_disable_stats(PyObject *self, PyObject *args) {
+ NRT_MemSys_disable_stats();
+ Py_RETURN_NONE;
+}
+
+/*
+ * Create a new MemInfo with a owner PyObject
+ */
+static PyObject *
+meminfo_new(PyObject *self, PyObject *args) {
+ PyObject *addr_data_obj;
+ void *addr_data;
+ PyObject *ownerobj;
+ NRT_MemInfo *mi;
+ if (!PyArg_ParseTuple(args, "OO", &addr_data_obj, &ownerobj)) {
+ return NULL;
+ }
+ addr_data = PyLong_AsVoidPtr(addr_data_obj);
+ if (PyErr_Occurred())
+ return NULL;
+ mi = NRT_meminfo_new_from_pyobject(addr_data, ownerobj);
+ return PyLong_FromVoidPtr(mi);
+}
+
+/*
+ * Create a new MemInfo with a new NRT allocation
+ */
+static PyObject *
+meminfo_alloc(PyObject *self, PyObject *args) {
+ NRT_MemInfo *mi;
+ Py_ssize_t size;
+ if (!PyArg_ParseTuple(args, "n", &size)) {
+ return NULL;
+ }
+ mi = NRT_MemInfo_alloc(size);
+ return PyLong_FromVoidPtr(mi);
+}
+
+/*
+ * Like meminfo_alloc but set memory to zero after allocation and before
+ * deallocation.
+ */
+static PyObject *
+meminfo_alloc_safe(PyObject *self, PyObject *args) {
+ NRT_MemInfo *mi;
+ Py_ssize_t size;
+ if (!PyArg_ParseTuple(args, "n", &size)) {
+ return NULL;
+ }
+ mi = NRT_MemInfo_alloc_safe(size);
+ return PyLong_FromVoidPtr(mi);
+}
+
+static PyMethodDef ext_methods[] = {
+#define declmethod(func) { #func , ( PyCFunction )func , METH_VARARGS , NULL }
+#define declmethod_noargs(func) { #func , ( PyCFunction )func , METH_NOARGS, NULL }
+ declmethod_noargs(memsys_use_cpython_allocator),
+ declmethod_noargs(memsys_shutdown),
+ declmethod_noargs(memsys_get_stats_alloc),
+ declmethod_noargs(memsys_get_stats_free),
+ declmethod_noargs(memsys_get_stats_mi_alloc),
+ declmethod_noargs(memsys_get_stats_mi_free),
+ declmethod_noargs(memsys_stats_enabled),
+ declmethod_noargs(memsys_enable_stats),
+ declmethod_noargs(memsys_disable_stats),
+ declmethod(meminfo_new),
+ declmethod(meminfo_alloc),
+ declmethod(meminfo_alloc_safe),
+ { NULL },
+#undef declmethod
+};
+
+
+
+static PyObject *
+build_c_helpers_dict(void)
+{
+ PyObject *dct = PyDict_New();
+ if (dct == NULL)
+ goto error;
+
+#define _declpointer(name, value) do { \
+ PyObject *o = PyLong_FromVoidPtr(value); \
+ if (o == NULL) goto error; \
+ if (PyDict_SetItemString(dct, name, o)) { \
+ Py_DECREF(o); \
+ goto error; \
+ } \
+ Py_DECREF(o); \
+} while (0)
+
+#define declmethod(func) _declpointer(#func, &NRT_##func)
+#define declmethod_internal(func) _declpointer(#func, &func)
+
+declmethod(adapt_ndarray_from_python);
+declmethod(adapt_ndarray_to_python_acqref);
+declmethod(adapt_buffer_from_python);
+declmethod(meminfo_new_from_pyobject);
+declmethod(meminfo_as_pyobject);
+declmethod(meminfo_from_pyobject);
+declmethod(MemInfo_alloc);
+declmethod(MemInfo_alloc_safe);
+declmethod(MemInfo_alloc_aligned);
+declmethod(MemInfo_alloc_safe_aligned);
+declmethod(MemInfo_alloc_safe_aligned_external);
+declmethod_internal(_nrt_get_sample_external_allocator);
+declmethod(MemInfo_alloc_dtor);
+declmethod(MemInfo_alloc_dtor_safe);
+declmethod(MemInfo_call_dtor);
+declmethod(MemInfo_new_varsize);
+declmethod(MemInfo_new_varsize_dtor);
+declmethod(MemInfo_varsize_alloc);
+declmethod(MemInfo_data);
+declmethod(MemInfo_varsize_free);
+declmethod(MemInfo_varsize_realloc);
+declmethod(MemInfo_release);
+declmethod(Allocate);
+declmethod(Free);
+declmethod(get_api);
+
+
+#undef declmethod
+#undef declmethod_internal
+ return dct;
+error:
+ Py_XDECREF(dct);
+ return NULL;
+}
+
+MOD_INIT(_nrt_python) {
+ PyObject *m;
+ MOD_DEF(m, "_nrt_python", "No docs", ext_methods)
+ if (m == NULL)
+ return MOD_ERROR_VAL;
+ import_array();
+ NRT_MemSys_init();
+ if (init_nrt_python_module(m))
+ return MOD_ERROR_VAL;
+
+ Py_INCREF(&MemInfoType);
+ PyModule_AddObject(m, "_MemInfo", (PyObject *) (&MemInfoType));
+
+ PyModule_AddObject(m, "c_helpers", build_c_helpers_dict());
+
+ return MOD_SUCCESS_VAL(m);
+}
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/context.py b/venv/lib/python3.10/site-packages/numba/core/runtime/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a8458d63027159914c19e658f65ba47bb9d8e08
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/context.py
@@ -0,0 +1,426 @@
+import functools
+from collections import namedtuple
+
+from llvmlite import ir
+from numba.core import types, cgutils, errors, config
+from numba.core.utils import PYVERSION
+
+
+_NRT_Meminfo_Functions = namedtuple("_NRT_Meminfo_Functions",
+ ("alloc",
+ "alloc_dtor",
+ "alloc_aligned"))
+
+
+_NRT_MEMINFO_SAFE_API = _NRT_Meminfo_Functions("NRT_MemInfo_alloc_safe",
+ "NRT_MemInfo_alloc_dtor_safe",
+ "NRT_MemInfo_alloc_safe_aligned")
+
+
+_NRT_MEMINFO_DEFAULT_API = _NRT_Meminfo_Functions("NRT_MemInfo_alloc",
+ "NRT_MemInfo_alloc_dtor",
+ "NRT_MemInfo_alloc_aligned")
+
+
+class NRTContext(object):
+ """
+ An object providing access to NRT APIs in the lowering pass.
+ """
+
+ def __init__(self, context, enabled):
+ self._context = context
+ self._enabled = enabled
+ # If DEBUG_NRT is set, use the safe function variants which use memset
+ # to inject a few known bytes into the start of allocated regions.
+ if config.DEBUG_NRT:
+ self._meminfo_api = _NRT_MEMINFO_SAFE_API
+ else:
+ self._meminfo_api = _NRT_MEMINFO_DEFAULT_API
+
+ def _require_nrt(self):
+ if not self._enabled:
+ raise errors.NumbaRuntimeError("NRT required but not enabled")
+
+ def _check_null_result(func):
+ @functools.wraps(func)
+ def wrap(self, builder, *args, **kwargs):
+ memptr = func(self, builder, *args, **kwargs)
+ msg = "Allocation failed (probably too large)."
+ cgutils.guard_memory_error(self._context, builder, memptr, msg=msg)
+ return memptr
+ return wrap
+
+ @_check_null_result
+ def allocate(self, builder, size):
+ """
+ Low-level allocate a new memory area of `size` bytes. The result of the
+ call is checked and if it is NULL, i.e. allocation failed, then a
+ MemoryError is raised.
+ """
+ return self.allocate_unchecked(builder, size)
+
+ def allocate_unchecked(self, builder, size):
+ """
+ Low-level allocate a new memory area of `size` bytes. Returns NULL to
+ indicate error/failure to allocate.
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(cgutils.voidptr_t, [cgutils.intp_t])
+ fn = cgutils.get_or_insert_function(mod, fnty, "NRT_Allocate")
+ fn.return_value.add_attribute("noalias")
+ return builder.call(fn, [size])
+
+ def free(self, builder, ptr):
+ """
+ Low-level free a memory area allocated with allocate().
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(ir.VoidType(), [cgutils.voidptr_t])
+ fn = cgutils.get_or_insert_function(mod, fnty, "NRT_Free")
+ return builder.call(fn, [ptr])
+
+ @_check_null_result
+ def meminfo_alloc(self, builder, size):
+ """
+ Allocate a new MemInfo with a data payload of `size` bytes.
+
+ A pointer to the MemInfo is returned.
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_alloc_unchecked(builder, size)
+
+ def meminfo_alloc_unchecked(self, builder, size):
+ """
+ Allocate a new MemInfo with a data payload of `size` bytes.
+
+ A pointer to the MemInfo is returned.
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(cgutils.voidptr_t, [cgutils.intp_t])
+ fn = cgutils.get_or_insert_function(mod, fnty,
+ self._meminfo_api.alloc)
+ fn.return_value.add_attribute("noalias")
+ return builder.call(fn, [size])
+
+ @_check_null_result
+ def meminfo_alloc_dtor(self, builder, size, dtor):
+ """
+ Allocate a new MemInfo with a data payload of `size` bytes and a
+ destructor `dtor`.
+
+ A pointer to the MemInfo is returned.
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_alloc_dtor_unchecked(builder, size, dtor)
+
+ def meminfo_alloc_dtor_unchecked(self, builder, size, dtor):
+ """
+ Allocate a new MemInfo with a data payload of `size` bytes and a
+ destructor `dtor`.
+
+ A pointer to the MemInfo is returned.
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(cgutils.voidptr_t,
+ [cgutils.intp_t, cgutils.voidptr_t])
+ fn = cgutils.get_or_insert_function(mod, fnty,
+ self._meminfo_api.alloc_dtor)
+ fn.return_value.add_attribute("noalias")
+ return builder.call(fn, [size,
+ builder.bitcast(dtor, cgutils.voidptr_t)])
+
+ @_check_null_result
+ def meminfo_alloc_aligned(self, builder, size, align):
+ """
+ Allocate a new MemInfo with an aligned data payload of `size` bytes.
+ The data pointer is aligned to `align` bytes. `align` can be either
+ a Python int or a LLVM uint32 value.
+
+ A pointer to the MemInfo is returned.
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_alloc_aligned_unchecked(builder, size, align)
+
+ def meminfo_alloc_aligned_unchecked(self, builder, size, align):
+ """
+ Allocate a new MemInfo with an aligned data payload of `size` bytes.
+ The data pointer is aligned to `align` bytes. `align` can be either
+ a Python int or a LLVM uint32 value.
+
+ A pointer to the MemInfo is returned.
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ u32 = ir.IntType(32)
+ fnty = ir.FunctionType(cgutils.voidptr_t, [cgutils.intp_t, u32])
+ fn = cgutils.get_or_insert_function(mod, fnty,
+ self._meminfo_api.alloc_aligned)
+ fn.return_value.add_attribute("noalias")
+ if isinstance(align, int):
+ align = self._context.get_constant(types.uint32, align)
+ else:
+ assert align.type == u32, "align must be a uint32"
+ return builder.call(fn, [size, align])
+
+ @_check_null_result
+ def meminfo_new_varsize(self, builder, size):
+ """
+ Allocate a MemInfo pointing to a variable-sized data area. The area
+ is separately allocated (i.e. two allocations are made) so that
+ re-allocating it doesn't change the MemInfo's address.
+
+ A pointer to the MemInfo is returned.
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_new_varsize_unchecked(builder, size)
+
+ def meminfo_new_varsize_unchecked(self, builder, size):
+ """
+ Allocate a MemInfo pointing to a variable-sized data area. The area
+ is separately allocated (i.e. two allocations are made) so that
+ re-allocating it doesn't change the MemInfo's address.
+
+ A pointer to the MemInfo is returned.
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(cgutils.voidptr_t, [cgutils.intp_t])
+ fn = cgutils.get_or_insert_function(mod, fnty,
+ "NRT_MemInfo_new_varsize")
+ fn.return_value.add_attribute("noalias")
+ return builder.call(fn, [size])
+
+ @_check_null_result
+ def meminfo_new_varsize_dtor(self, builder, size, dtor):
+ """
+ Like meminfo_new_varsize() but also set the destructor for
+ cleaning up references to objects inside the allocation.
+
+ A pointer to the MemInfo is returned.
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_new_varsize_dtor_unchecked(builder, size, dtor)
+
+ def meminfo_new_varsize_dtor_unchecked(self, builder, size, dtor):
+ """
+ Like meminfo_new_varsize() but also set the destructor for
+ cleaning up references to objects inside the allocation.
+
+ A pointer to the MemInfo is returned.
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(cgutils.voidptr_t,
+ [cgutils.intp_t, cgutils.voidptr_t])
+ fn = cgutils.get_or_insert_function(
+ mod, fnty, "NRT_MemInfo_new_varsize_dtor")
+ return builder.call(fn, [size, dtor])
+
+ @_check_null_result
+ def meminfo_varsize_alloc(self, builder, meminfo, size):
+ """
+ Allocate a new data area for a MemInfo created by meminfo_new_varsize().
+ The new data pointer is returned, for convenience.
+
+ Contrary to realloc(), this always allocates a new area and doesn't
+ copy the old data. This is useful if resizing a container needs
+ more than simply copying the data area (e.g. for hash tables).
+
+ The old pointer will have to be freed with meminfo_varsize_free().
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_varsize_alloc_unchecked(builder, meminfo, size)
+
+ def meminfo_varsize_alloc_unchecked(self, builder, meminfo, size):
+ """
+ Allocate a new data area for a MemInfo created by meminfo_new_varsize().
+ The new data pointer is returned, for convenience.
+
+ Contrary to realloc(), this always allocates a new area and doesn't
+ copy the old data. This is useful if resizing a container needs
+ more than simply copying the data area (e.g. for hash tables).
+
+ The old pointer will have to be freed with meminfo_varsize_free().
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ return self._call_varsize_alloc(builder, meminfo, size,
+ "NRT_MemInfo_varsize_alloc")
+
+ @_check_null_result
+ def meminfo_varsize_realloc(self, builder, meminfo, size):
+ """
+ Reallocate a data area allocated by meminfo_new_varsize().
+ The new data pointer is returned, for convenience.
+
+ The result of the call is checked and if it is NULL, i.e. allocation
+ failed, then a MemoryError is raised.
+ """
+ return self.meminfo_varsize_realloc_unchecked(builder, meminfo, size)
+
+ def meminfo_varsize_realloc_unchecked(self, builder, meminfo, size):
+ """
+ Reallocate a data area allocated by meminfo_new_varsize().
+ The new data pointer is returned, for convenience.
+
+ Returns NULL to indicate error/failure to allocate.
+ """
+ return self._call_varsize_alloc(builder, meminfo, size,
+ "NRT_MemInfo_varsize_realloc")
+
+ def meminfo_varsize_free(self, builder, meminfo, ptr):
+ """
+ Free a memory area allocated for a NRT varsize object.
+ Note this does *not* free the NRT object itself!
+ """
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(ir.VoidType(),
+ [cgutils.voidptr_t, cgutils.voidptr_t])
+ fn = cgutils.get_or_insert_function(mod, fnty,
+ "NRT_MemInfo_varsize_free")
+ return builder.call(fn, (meminfo, ptr))
+
+ def _call_varsize_alloc(self, builder, meminfo, size, funcname):
+ self._require_nrt()
+
+ mod = builder.module
+ fnty = ir.FunctionType(cgutils.voidptr_t,
+ [cgutils.voidptr_t, cgutils.intp_t])
+ fn = cgutils.get_or_insert_function(mod, fnty, funcname)
+ fn.return_value.add_attribute("noalias")
+ return builder.call(fn, [meminfo, size])
+
+ def meminfo_data(self, builder, meminfo):
+ """
+ Given a MemInfo pointer, return a pointer to the allocated data
+ managed by it. This works for MemInfos allocated with all the
+ above methods.
+ """
+ self._require_nrt()
+
+ from numba.core.runtime.nrtdynmod import meminfo_data_ty
+
+ mod = builder.module
+ fn = cgutils.get_or_insert_function(mod, meminfo_data_ty,
+ "NRT_MemInfo_data_fast")
+ return builder.call(fn, [meminfo])
+
+ def get_meminfos(self, builder, ty, val):
+ """Return a list of *(type, meminfo)* inside the given value.
+ """
+ datamodel = self._context.data_model_manager[ty]
+ members = datamodel.traverse(builder)
+
+ meminfos = []
+ if datamodel.has_nrt_meminfo():
+ mi = datamodel.get_nrt_meminfo(builder, val)
+ meminfos.append((ty, mi))
+
+ for mtyp, getter in members:
+ field = getter(val)
+ inner_meminfos = self.get_meminfos(builder, mtyp, field)
+ meminfos.extend(inner_meminfos)
+ return meminfos
+
+ def _call_incref_decref(self, builder, typ, value, funcname):
+ """Call function of *funcname* on every meminfo found in *value*.
+ """
+ self._require_nrt()
+
+ from numba.core.runtime.nrtdynmod import incref_decref_ty
+
+ meminfos = self.get_meminfos(builder, typ, value)
+ for _, mi in meminfos:
+ mod = builder.module
+ fn = cgutils.get_or_insert_function(mod, incref_decref_ty,
+ funcname)
+ # XXX "nonnull" causes a crash in test_dyn_array: can this
+ # function be called with a NULL pointer?
+ fn.args[0].add_attribute("noalias")
+ fn.args[0].add_attribute("nocapture")
+ builder.call(fn, [mi])
+
+ def incref(self, builder, typ, value):
+ """
+ Recursively incref the given *value* and its members.
+ """
+ self._call_incref_decref(builder, typ, value, "NRT_incref")
+
+ def decref(self, builder, typ, value):
+ """
+ Recursively decref the given *value* and its members.
+ """
+ self._call_incref_decref(builder, typ, value, "NRT_decref")
+
+ def get_nrt_api(self, builder):
+ """Calls NRT_get_api(), which returns the NRT API function table.
+ """
+ self._require_nrt()
+
+ fnty = ir.FunctionType(cgutils.voidptr_t, ())
+ mod = builder.module
+ fn = cgutils.get_or_insert_function(mod, fnty, "NRT_get_api")
+ return builder.call(fn, ())
+
+ def eh_check(self, builder):
+ """Check if an exception is raised
+ """
+ ctx = self._context
+ cc = ctx.call_conv
+ # Inspect the excinfo argument on the function
+ trystatus = cc.check_try_status(builder)
+ excinfo = trystatus.excinfo
+ has_raised = builder.not_(cgutils.is_null(builder, excinfo))
+ if PYVERSION < (3, 11):
+ with builder.if_then(has_raised):
+ self.eh_end_try(builder)
+ return has_raised
+
+ def eh_try(self, builder):
+ """Begin a try-block.
+ """
+ ctx = self._context
+ cc = ctx.call_conv
+ cc.set_try_status(builder)
+
+ def eh_end_try(self, builder):
+ """End a try-block
+ """
+ ctx = self._context
+ cc = ctx.call_conv
+ cc.unset_try_status(builder)
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.cpp b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e5644faf45c0a2d16cd11247d6bacd98ece91952
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.cpp
@@ -0,0 +1,629 @@
+/* MSVC C99 doesn't have , else this could be written in easily
+ * in C */
+#include
+
+#ifdef _MSC_VER
+#include
+#endif
+
+#include
+#include /* for memset */
+#include "nrt.h"
+#include "assert.h"
+
+
+/* NOTE: if changing the layout, please update numba.core.runtime.atomicops */
+extern "C" {
+struct MemInfo {
+ std::atomic_size_t refct;
+ NRT_dtor_function dtor;
+ void *dtor_info;
+ void *data;
+ size_t size; /* only used for NRT allocated memory */
+ NRT_ExternalAllocator *external_allocator;
+};
+}
+
+
+/*
+ * Misc helpers.
+ */
+
+static void nrt_fatal_error(const char *msg)
+{
+ fprintf(stderr, "Fatal Numba error: %s\n", msg);
+ fflush(stderr); /* it helps in Windows debug build */
+
+#if defined(MS_WINDOWS) && defined(_DEBUG)
+ DebugBreak();
+#endif
+ abort();
+}
+
+/*
+ * Global resources.
+ */
+
+struct NRT_MemSys {
+ /* Shutdown flag */
+ int shutting;
+ /* Stats */
+ struct {
+ bool enabled;
+ std::atomic_size_t alloc;
+ std::atomic_size_t free;
+ std::atomic_size_t mi_alloc;
+ std::atomic_size_t mi_free;
+ } stats;
+ /* System allocation functions */
+ struct {
+ NRT_malloc_func malloc;
+ NRT_realloc_func realloc;
+ NRT_free_func free;
+ } allocator;
+};
+
+
+/* The Memory System object */
+static NRT_MemSys TheMSys;
+
+
+extern "C" void NRT_MemSys_init(void) {
+ TheMSys.shutting = 0;
+ // Stats are off by default, call NRT_MemSys_enable_stats to enable
+ TheMSys.stats.enabled = false;
+ TheMSys.stats.alloc = 0;
+ TheMSys.stats.free = 0;
+ TheMSys.stats.mi_alloc = 0;
+ TheMSys.stats.mi_free = 0;
+ /* Bind to libc allocator */
+ TheMSys.allocator.malloc = malloc;
+ TheMSys.allocator.realloc = realloc;
+ TheMSys.allocator.free = free;
+}
+
+extern "C" void NRT_MemSys_shutdown(void) {
+ TheMSys.shutting = 1;
+}
+
+extern "C" void NRT_MemSys_enable_stats(void) {
+ TheMSys.stats.enabled = true;
+}
+
+extern "C" void NRT_MemSys_disable_stats(void) {
+ TheMSys.stats.enabled = false;
+}
+
+extern "C" size_t NRT_MemSys_stats_enabled(void) {
+ return (size_t)TheMSys.stats.enabled;
+}
+
+extern "C" void NRT_MemSys_set_allocator(NRT_malloc_func malloc_func,
+ NRT_realloc_func realloc_func,
+ NRT_free_func free_func)
+{
+ bool stats_cond = false;
+ if (TheMSys.stats.enabled)
+ {
+ stats_cond = (TheMSys.stats.alloc != TheMSys.stats.free ||
+ TheMSys.stats.mi_alloc != TheMSys.stats.mi_free);
+ }
+ if ((malloc_func != TheMSys.allocator.malloc ||
+ realloc_func != TheMSys.allocator.realloc ||
+ free_func != TheMSys.allocator.free) &&
+ stats_cond) {
+ nrt_fatal_error("cannot change allocator while blocks are allocated");
+ }
+ TheMSys.allocator.malloc = malloc_func;
+ TheMSys.allocator.realloc = realloc_func;
+ TheMSys.allocator.free = free_func;
+}
+
+/* This value is used as a marker for "stats are disabled", it's ASCII "AAAA" */
+static size_t _DISABLED_STATS_VALUE = 0x41414141;
+
+extern "C" size_t NRT_MemSys_get_stats_alloc() {
+ if (TheMSys.stats.enabled)
+ {
+ return TheMSys.stats.alloc.load();
+ } else {
+ return _DISABLED_STATS_VALUE;
+ }
+}
+
+extern "C" size_t NRT_MemSys_get_stats_free() {
+ if (TheMSys.stats.enabled)
+ {
+ return TheMSys.stats.free.load();
+ } else {
+ return _DISABLED_STATS_VALUE;
+ }
+}
+
+extern "C" size_t NRT_MemSys_get_stats_mi_alloc() {
+ if (TheMSys.stats.enabled)
+ {
+ return TheMSys.stats.mi_alloc.load();
+ } else {
+ return _DISABLED_STATS_VALUE;
+ }
+}
+
+extern "C" size_t NRT_MemSys_get_stats_mi_free() {
+ if (TheMSys.stats.enabled)
+ {
+ return TheMSys.stats.mi_free.load();
+ } else {
+ return _DISABLED_STATS_VALUE;
+ }
+}
+
+/*
+ * The MemInfo structure.
+ */
+
+extern "C" void NRT_MemInfo_init(NRT_MemInfo *mi,void *data, size_t size,
+ NRT_dtor_function dtor, void *dtor_info,
+ NRT_ExternalAllocator *external_allocator)
+{
+ mi->refct = 1; /* starts with 1 refct */
+ mi->dtor = dtor;
+ mi->dtor_info = dtor_info;
+ mi->data = data;
+ mi->size = size;
+ mi->external_allocator = external_allocator;
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_init mi=%p external_allocator=%p\n", mi, external_allocator));
+ /* Update stats */
+ if (TheMSys.stats.enabled)
+ {
+ TheMSys.stats.mi_alloc++;
+ }
+}
+
+NRT_MemInfo *NRT_MemInfo_new(void *data, size_t size,
+ NRT_dtor_function dtor, void *dtor_info)
+{
+ NRT_MemInfo *mi = (NRT_MemInfo *)NRT_Allocate(sizeof(NRT_MemInfo));
+ if (mi != NULL) {
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_new mi=%p\n", mi));
+ NRT_MemInfo_init(mi, data, size, dtor, dtor_info, NULL);
+ }
+ return mi;
+}
+
+size_t NRT_MemInfo_refcount(NRT_MemInfo *mi) {
+ /* Should never returns 0 for a valid MemInfo */
+ if (mi && mi->data)
+ return mi->refct;
+ else{
+ return (size_t)-1;
+ }
+}
+
+static
+void nrt_internal_dtor_safe(void *ptr, size_t size, void *info) {
+ NRT_Debug(nrt_debug_print("nrt_internal_dtor_safe %p, %p\n", ptr, info));
+ /* See NRT_MemInfo_alloc_safe() */
+ /* Fill region with debug markers */
+ memset(ptr, 0xDE, size);
+}
+
+static
+void *nrt_allocate_meminfo_and_data(size_t size, NRT_MemInfo **mi_out, NRT_ExternalAllocator *allocator) {
+ NRT_MemInfo *mi = NULL;
+ NRT_Debug(nrt_debug_print("nrt_allocate_meminfo_and_data %p\n", allocator));
+ char *base = (char *)NRT_Allocate_External(sizeof(NRT_MemInfo) + size, allocator);
+ if (base == NULL) {
+ *mi_out = NULL; /* set meminfo to NULL as allocation failed */
+ return NULL; /* return early as allocation failed */
+ }
+ mi = (NRT_MemInfo *) base;
+ *mi_out = mi;
+ return (void*)((char *)base + sizeof(NRT_MemInfo));
+}
+
+
+static
+void nrt_internal_custom_dtor_safe(void *ptr, size_t size, void *info) {
+ NRT_dtor_function dtor = (NRT_dtor_function)info;
+ NRT_Debug(nrt_debug_print("nrt_internal_custom_dtor_safe %p, %p\n",
+ ptr, info));
+ if (dtor) {
+ dtor(ptr, size, NULL);
+ }
+
+ nrt_internal_dtor_safe(ptr, size, NULL);
+}
+
+static
+void nrt_internal_custom_dtor(void *ptr, size_t size, void *info) {
+ NRT_dtor_function dtor = (NRT_dtor_function)info;
+ NRT_Debug(nrt_debug_print("nrt_internal_custom_dtor %p, %p\n",
+ ptr, info));
+ if (dtor) {
+ dtor(ptr, size, NULL);
+ }
+}
+
+NRT_MemInfo *NRT_MemInfo_alloc(size_t size) {
+ NRT_MemInfo *mi = NULL;
+ void *data = nrt_allocate_meminfo_and_data(size, &mi, NULL);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc %p\n", data));
+ NRT_MemInfo_init(mi, data, size, NULL, NULL, NULL);
+ return mi;
+}
+
+extern "C" NRT_MemInfo *NRT_MemInfo_alloc_external(size_t size, NRT_ExternalAllocator *allocator) {
+ NRT_MemInfo *mi = NULL;
+ void *data = nrt_allocate_meminfo_and_data(size, &mi, allocator);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc %p\n", data));
+ NRT_MemInfo_init(mi, data, size, NULL, NULL, allocator);
+ return mi;
+}
+
+extern "C" NRT_MemInfo *NRT_MemInfo_alloc_safe(size_t size) {
+ return NRT_MemInfo_alloc_dtor_safe(size, NULL);
+}
+
+extern "C" NRT_MemInfo* NRT_MemInfo_alloc_dtor_safe(size_t size, NRT_dtor_function dtor) {
+ NRT_MemInfo *mi = NULL;
+ void *data = nrt_allocate_meminfo_and_data(size, &mi, NULL);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ /* Fill region with debug markers */
+ memset(data, 0xCB, size);
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc_dtor_safe %p %zu\n", data, size));
+ NRT_MemInfo_init(mi, data, size, nrt_internal_custom_dtor_safe, (void*)dtor, NULL);
+ return mi;
+}
+
+NRT_MemInfo* NRT_MemInfo_alloc_dtor(size_t size, NRT_dtor_function dtor) {
+ NRT_MemInfo *mi = NULL;
+ void *data = (void *)nrt_allocate_meminfo_and_data(size, &mi, NULL);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc_dtor %p %zu\n", data, size));
+ NRT_MemInfo_init(mi, data, size, nrt_internal_custom_dtor, (void *)dtor, NULL);
+ return mi;
+}
+
+static
+void *nrt_allocate_meminfo_and_data_align(size_t size, unsigned align,
+ NRT_MemInfo **mi, NRT_ExternalAllocator *allocator)
+{
+ size_t offset = 0, intptr = 0, remainder = 0;
+ NRT_Debug(nrt_debug_print("nrt_allocate_meminfo_and_data_align %p\n", allocator));
+ char *base = (char *)nrt_allocate_meminfo_and_data(size + 2 * align, mi, allocator);
+ if (base == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ intptr = (size_t) base;
+ /*
+ * See if the allocation is aligned already...
+ * Check if align is a power of 2, if so the modulo can be avoided.
+ */
+ if((align & (align - 1)) == 0)
+ {
+ remainder = intptr & (align - 1);
+ }
+ else
+ {
+ remainder = intptr % align;
+ }
+ if (remainder == 0){ /* Yes */
+ offset = 0;
+ } else { /* No, move forward `offset` bytes */
+ offset = align - remainder;
+ }
+ return (void*)((char *)base + offset);
+}
+
+extern "C" NRT_MemInfo *NRT_MemInfo_alloc_aligned(size_t size, unsigned align) {
+ NRT_MemInfo *mi = NULL;
+ void *data = nrt_allocate_meminfo_and_data_align(size, align, &mi, NULL);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc_aligned %p\n", data));
+ NRT_MemInfo_init(mi, data, size, NULL, NULL, NULL);
+ return mi;
+}
+
+extern "C" NRT_MemInfo *NRT_MemInfo_alloc_safe_aligned(size_t size, unsigned align) {
+ NRT_MemInfo *mi = NULL;
+ void *data = nrt_allocate_meminfo_and_data_align(size, align, &mi, NULL);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ /* Fill region with debug markers */
+ memset(data, 0xCB, size);
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc_safe_aligned %p %zu\n",
+ data, size));
+ NRT_MemInfo_init(mi, data, size, nrt_internal_dtor_safe, (void*)size, NULL);
+ return mi;
+}
+
+extern "C" NRT_MemInfo *NRT_MemInfo_alloc_safe_aligned_external(size_t size, unsigned align, NRT_ExternalAllocator *allocator) {
+ NRT_MemInfo *mi = NULL;
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc_safe_aligned_external %p\n", allocator));
+ void *data = nrt_allocate_meminfo_and_data_align(size, align, &mi, allocator);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+ /* Fill region with debug markers */
+ memset(data, 0xCB, size);
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_alloc_safe_aligned %p %zu\n",
+ data, size));
+ NRT_MemInfo_init(mi, data, size, nrt_internal_dtor_safe, (void*)size, allocator);
+ return mi;
+}
+
+extern "C" void NRT_dealloc(NRT_MemInfo *mi) {
+ NRT_Debug(nrt_debug_print("NRT_dealloc meminfo: %p external_allocator: %p\n", mi, mi->external_allocator));
+ if (mi->external_allocator) {
+ mi->external_allocator->free(mi, mi->external_allocator->opaque_data);
+ if (TheMSys.stats.enabled)
+ {
+ TheMSys.stats.free++;
+ }
+ } else {
+ NRT_Free(mi);
+ }
+}
+
+extern "C" void NRT_MemInfo_destroy(NRT_MemInfo *mi) {
+ NRT_dealloc(mi);
+ if (TheMSys.stats.enabled)
+ {
+ TheMSys.stats.mi_free++;
+ }
+}
+
+extern "C" void NRT_MemInfo_acquire(NRT_MemInfo *mi) {
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_acquire %p refct=%zu\n", mi,
+ mi->refct.load()));
+ assert(mi->refct > 0 && "RefCt cannot be zero");
+ mi->refct++;
+}
+
+extern "C" void NRT_MemInfo_call_dtor(NRT_MemInfo *mi) {
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_call_dtor %p\n", mi));
+ if (mi->dtor && !TheMSys.shutting)
+ /* We have a destructor and the system is not shutting down */
+ mi->dtor(mi->data, mi->size, mi->dtor_info);
+ /* Clear and release MemInfo */
+ NRT_MemInfo_destroy(mi);
+}
+
+extern "C" void NRT_MemInfo_release(NRT_MemInfo *mi) {
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_release %p refct=%zu\n", mi,
+ mi->refct.load()));
+ assert (mi->refct > 0 && "RefCt cannot be 0");
+ /* RefCt drop to zero */
+ if ((--(mi->refct)) == 0) {
+ NRT_MemInfo_call_dtor(mi);
+ }
+}
+
+extern "C" void* NRT_MemInfo_data(NRT_MemInfo* mi) {
+ return mi->data;
+}
+
+size_t NRT_MemInfo_size(NRT_MemInfo* mi) {
+ return mi->size;
+}
+
+extern "C" void * NRT_MemInfo_external_allocator(NRT_MemInfo *mi) {
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_external_allocator meminfo: %p external_allocator: %p\n", mi, mi->external_allocator));
+ return mi->external_allocator;
+}
+
+extern "C" void *NRT_MemInfo_parent(NRT_MemInfo *mi) {
+ return mi->dtor_info;
+}
+
+extern "C" void NRT_MemInfo_dump(NRT_MemInfo *mi, FILE *out) {
+ fprintf(out, "MemInfo %p refcount %zu\n", mi, mi->refct.load());
+}
+
+/*
+ * Resizable buffer API.
+ */
+
+static void
+nrt_varsize_dtor(void *ptr, size_t size, void *info) {
+ NRT_Debug(nrt_debug_print("nrt_varsize_dtor %p\n", ptr));
+ if (info) {
+ /* call element dtor */
+ typedef void dtor_fn_t(void *ptr);
+ dtor_fn_t *dtor = (dtor_fn_t *)info;
+ dtor(ptr);
+ }
+ NRT_Free(ptr);
+}
+
+NRT_MemInfo *NRT_MemInfo_new_varsize(size_t size)
+{
+ NRT_MemInfo *mi = NULL;
+ void *data = NRT_Allocate(size);
+ if (data == NULL) {
+ return NULL; /* return early as allocation failed */
+ }
+
+ mi = NRT_MemInfo_new(data, size, nrt_varsize_dtor, NULL);
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_new_varsize size=%zu "
+ "-> meminfo=%p, data=%p\n", size, mi, data));
+ return mi;
+}
+
+NRT_MemInfo *NRT_MemInfo_new_varsize_dtor(size_t size, NRT_dtor_function dtor) {
+ NRT_MemInfo *mi = NRT_MemInfo_new_varsize(size);
+ if (mi) {
+ mi->dtor_info = (void*)dtor;
+ }
+ return mi;
+}
+
+extern "C" void *NRT_MemInfo_varsize_alloc(NRT_MemInfo *mi, size_t size)
+{
+ if (mi->dtor != nrt_varsize_dtor) {
+ nrt_fatal_error("ERROR: NRT_MemInfo_varsize_alloc called "
+ "with a non varsize-allocated meminfo");
+ return NULL; /* unreachable */
+ }
+ mi->data = NRT_Allocate(size);
+ if (mi->data == NULL)
+ return NULL;
+ mi->size = size;
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_varsize_alloc %p size=%zu "
+ "-> data=%p\n", mi, size, mi->data));
+ return mi->data;
+}
+
+extern "C" void *NRT_MemInfo_varsize_realloc(NRT_MemInfo *mi, size_t size)
+{
+ if (mi->dtor != nrt_varsize_dtor) {
+ nrt_fatal_error("ERROR: NRT_MemInfo_varsize_realloc called "
+ "with a non varsize-allocated meminfo");
+ return NULL; /* unreachable */
+ }
+ mi->data = NRT_Reallocate(mi->data, size);
+ if (mi->data == NULL)
+ return NULL;
+ mi->size = size;
+ NRT_Debug(nrt_debug_print("NRT_MemInfo_varsize_realloc %p size=%zu "
+ "-> data=%p\n", mi, size, mi->data));
+ return mi->data;
+}
+
+extern "C" void NRT_MemInfo_varsize_free(NRT_MemInfo *mi, void *ptr)
+{
+ NRT_Free(ptr);
+ if (ptr == mi->data)
+ mi->data = NULL;
+}
+
+/*
+ * Low-level allocation wrappers.
+ */
+
+extern "C" void* NRT_Allocate(size_t size) {
+ return NRT_Allocate_External(size, NULL);
+}
+
+extern "C" void* NRT_Allocate_External(size_t size, NRT_ExternalAllocator *allocator) {
+ void *ptr = NULL;
+ if (allocator) {
+ ptr = allocator->malloc(size, allocator->opaque_data);
+ NRT_Debug(nrt_debug_print("NRT_Allocate_External custom bytes=%zu ptr=%p\n", size, ptr));
+ } else {
+ ptr = TheMSys.allocator.malloc(size);
+ NRT_Debug(nrt_debug_print("NRT_Allocate_External bytes=%zu ptr=%p\n", size, ptr));
+ }
+ if (TheMSys.stats.enabled)
+ {
+ TheMSys.stats.alloc++;
+ }
+ return ptr;
+}
+
+extern "C" void *NRT_Reallocate(void *ptr, size_t size) {
+ void *new_ptr = TheMSys.allocator.realloc(ptr, size);
+ NRT_Debug(nrt_debug_print("NRT_Reallocate bytes=%zu ptr=%p -> %p\n",
+ size, ptr, new_ptr));
+ return new_ptr;
+}
+
+extern "C" void NRT_Free(void *ptr) {
+ NRT_Debug(nrt_debug_print("NRT_Free %p\n", ptr));
+ TheMSys.allocator.free(ptr);
+ if (TheMSys.stats.enabled)
+ {
+ TheMSys.stats.free++;
+ }
+}
+
+/*
+ * Sample external allocator implementation for internal testing.
+ */
+
+static int sample_external_opaque_data = 0xabacad;
+
+static
+void* sample_external_malloc(size_t size, void* opaque_data) {
+ if (opaque_data != &sample_external_opaque_data) return NULL;
+ return TheMSys.allocator.malloc(size);
+}
+
+static
+void* sample_external_realloc(void *ptr, size_t new_size, void *opaque_data) {
+ if (opaque_data != &sample_external_opaque_data) return NULL;
+ return TheMSys.allocator.realloc(ptr, new_size);
+}
+
+static
+void sample_external_free(void *ptr, void* opaque_data) {
+ TheMSys.allocator.free(ptr);
+}
+
+static NRT_ExternalAllocator sample_external_allocator = {
+ // malloc
+ sample_external_malloc,
+ // realloc
+ sample_external_realloc,
+ // free
+ sample_external_free,
+ // opaque_data
+ &sample_external_opaque_data
+};
+
+extern "C" NRT_ExternalAllocator* _nrt_get_sample_external_allocator() {
+ return &sample_external_allocator;
+}
+
+/*
+ * Debugging printf function used internally
+ */
+void nrt_debug_print(const char *fmt, ...) {
+ va_list args;
+
+ va_start(args, fmt);
+ vfprintf(stderr, fmt, args);
+ va_end(args);
+}
+
+
+static
+void nrt_manage_memory_dtor(void *data, size_t size, void *info) {
+ NRT_managed_dtor* dtor = (NRT_managed_dtor*)info;
+ dtor(data);
+}
+
+static
+NRT_MemInfo* nrt_manage_memory(void *data, NRT_managed_dtor dtor) {
+ return (NRT_MemInfo*)(NRT_MemInfo_new(data, 0, nrt_manage_memory_dtor, (void*)dtor));
+}
+
+
+static const
+NRT_api_functions nrt_functions_table = {
+ NRT_MemInfo_alloc,
+ NRT_MemInfo_alloc_external,
+ nrt_manage_memory,
+ NRT_MemInfo_acquire,
+ NRT_MemInfo_release,
+ NRT_MemInfo_data
+};
+
+
+extern "C" const NRT_api_functions* NRT_get_api(void) {
+ return &nrt_functions_table;
+}
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.h b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8fe1f22aa16b622213ca03cdc9523299e6c9a90
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.h
@@ -0,0 +1,273 @@
+/*
+All functions described here are threadsafe.
+*/
+
+#ifndef NUMBA_NRT_H_
+#define NUMBA_NRT_H_
+
+
+#include
+#include
+#include "../../_numba_common.h"
+
+#include "nrt_external.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* Debugging facilities - enabled at compile-time */
+/* #undef NDEBUG */
+#if 0
+# define NRT_Debug(X) {X; fflush(stdout); }
+#else
+# define NRT_Debug(X) if (0) { X; }
+#endif
+
+/* TypeDefs */
+typedef void (*NRT_dtor_function)(void *ptr, size_t size, void *info);
+typedef void (*NRT_dealloc_func)(void *ptr, void *dealloc_info);
+
+typedef void *(*NRT_malloc_func)(size_t size);
+typedef void *(*NRT_realloc_func)(void *ptr, size_t new_size);
+typedef void (*NRT_free_func)(void *ptr);
+
+/* Memory System API */
+
+/* Initialize the memory system */
+VISIBILITY_HIDDEN
+void NRT_MemSys_init(void);
+
+/* Shutdown the memory system */
+VISIBILITY_HIDDEN
+void NRT_MemSys_shutdown(void);
+
+/*
+ * Register the system allocation functions
+ */
+VISIBILITY_HIDDEN
+void NRT_MemSys_set_allocator(NRT_malloc_func, NRT_realloc_func, NRT_free_func);
+
+/*
+ * Enable the internal statistics counters.
+ */
+VISIBILITY_HIDDEN
+void NRT_MemSys_enable_stats(void);
+
+/*
+ * Disable the internal statistics counters.
+ */
+VISIBILITY_HIDDEN
+void NRT_MemSys_disable_stats(void);
+
+/*
+ * Query whether the internal statistics counters are enabled.
+ * Returns 1 if they are, 0 if they are not.
+ */
+VISIBILITY_HIDDEN
+size_t NRT_MemSys_stats_enabled(void);
+
+/*
+ * The following functions get internal statistics of the memory subsystem.
+ */
+VISIBILITY_HIDDEN
+size_t NRT_MemSys_get_stats_alloc(void);
+VISIBILITY_HIDDEN
+size_t NRT_MemSys_get_stats_free(void);
+VISIBILITY_HIDDEN
+size_t NRT_MemSys_get_stats_mi_alloc(void);
+VISIBILITY_HIDDEN
+size_t NRT_MemSys_get_stats_mi_free(void);
+
+/* Memory Info API */
+
+/* Create a new MemInfo for external memory
+ *
+ * data: data pointer being tracked
+ * dtor: destructor to execute
+ * dtor_info: additional information to pass to the destructor
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo* NRT_MemInfo_new(void *data, size_t size,
+ NRT_dtor_function dtor, void *dtor_info);
+
+/*
+ * The `external_allocator` is for experimental API to customize the allocator.
+ * Set to NULL to use the default builtin allocator.
+ */
+VISIBILITY_HIDDEN
+void NRT_MemInfo_init(NRT_MemInfo *mi, void *data, size_t size,
+ NRT_dtor_function dtor, void *dtor_info,
+ NRT_ExternalAllocator *external_allocator);
+
+/*
+ * Returns the refcount of a MemInfo or (size_t)-1 if error.
+ */
+VISIBILITY_HIDDEN
+size_t NRT_MemInfo_refcount(NRT_MemInfo *mi);
+
+/*
+ * Allocate memory of `size` bytes and return a pointer to a MemInfo structure
+ * that describes the allocation
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo *NRT_MemInfo_alloc(size_t size);
+
+NRT_MemInfo *NRT_MemInfo_alloc_external(size_t size, NRT_ExternalAllocator *allocator);
+
+/*
+ * The "safe" NRT_MemInfo_alloc performs additional steps to help debug
+ * memory errors.
+ * It is guaranteed to:
+ * - zero-fill to the memory region after allocation and before deallocation.
+ * - may do more in the future
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo *NRT_MemInfo_alloc_safe(size_t size);
+
+/*
+ * Similar to NRT_MemInfo_alloc_safe but with a custom dtor.
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo* NRT_MemInfo_alloc_dtor_safe(size_t size, NRT_dtor_function dtor);
+
+/*
+ * Similar to NRT_MemInfo_alloc but with a custom dtor.
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo* NRT_MemInfo_alloc_dtor(size_t size, NRT_dtor_function dtor);
+
+/*
+ * Aligned versions of the NRT_MemInfo_alloc and NRT_MemInfo_alloc_safe.
+ * These take an additional argument `align` for number of bytes to align to.
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo *NRT_MemInfo_alloc_aligned(size_t size, unsigned align);
+VISIBILITY_HIDDEN
+NRT_MemInfo *NRT_MemInfo_alloc_safe_aligned(size_t size, unsigned align);
+
+/*
+ * Experimental.
+ * A variation to use an external allocator.
+ */
+NRT_MemInfo *NRT_MemInfo_alloc_safe_aligned_external(size_t size, unsigned align, NRT_ExternalAllocator *allocator);
+
+/*
+ * Internal API.
+ * Release a MemInfo. Calls NRT_MemSys_insert_meminfo.
+ */
+VISIBILITY_HIDDEN
+void NRT_MemInfo_destroy(NRT_MemInfo *mi);
+
+/*
+ * Acquire a reference to a MemInfo
+ */
+VISIBILITY_HIDDEN
+void NRT_MemInfo_acquire(NRT_MemInfo* mi);
+
+/*
+ * Release a reference to a MemInfo
+ */
+VISIBILITY_HIDDEN
+void NRT_MemInfo_release(NRT_MemInfo* mi);
+
+/*
+ * Internal/Compiler API.
+ * Invoke the registered destructor of a MemInfo.
+ */
+VISIBILITY_HIDDEN
+void NRT_MemInfo_call_dtor(NRT_MemInfo *mi);
+
+/*
+ * Returns the data pointer
+ */
+VISIBILITY_HIDDEN
+void* NRT_MemInfo_data(NRT_MemInfo* mi);
+
+/*
+ * Returns the allocated size
+ */
+VISIBILITY_HIDDEN
+size_t NRT_MemInfo_size(NRT_MemInfo* mi);
+
+
+/*
+ * Experimental.
+ * Returns the external allocator
+ */
+VISIBILITY_HIDDEN
+void* NRT_MemInfo_external_allocator(NRT_MemInfo* mi);
+
+/*
+ * Returns the parent MemInfo
+ */
+VISIBILITY_HIDDEN
+void* NRT_MemInfo_parent(NRT_MemInfo* mi);
+
+
+/*
+ * NRT API for resizable buffers.
+ */
+VISIBILITY_HIDDEN
+NRT_MemInfo *NRT_MemInfo_new_varsize(size_t size);
+VISIBILITY_HIDDEN
+NRT_MemInfo *NRT_MemInfo_new_varsize_dtor(size_t size, NRT_dtor_function dtor);
+VISIBILITY_HIDDEN
+void *NRT_MemInfo_varsize_alloc(NRT_MemInfo *mi, size_t size);
+VISIBILITY_HIDDEN
+void *NRT_MemInfo_varsize_realloc(NRT_MemInfo *mi, size_t size);
+VISIBILITY_HIDDEN
+void NRT_MemInfo_varsize_free(NRT_MemInfo *mi, void *ptr);
+
+/*
+ * Print debug info to FILE
+ */
+VISIBILITY_HIDDEN
+void NRT_MemInfo_dump(NRT_MemInfo *mi, FILE *out);
+
+
+/* Low-level allocation wrappers. */
+
+/*
+ * Allocate memory of `size` bytes.
+ */
+VISIBILITY_HIDDEN void* NRT_Allocate(size_t size);
+
+/*
+ * Experimental
+ *
+ * An alternative allocator that allows using an external allocator.
+ */
+VISIBILITY_HIDDEN void* NRT_Allocate_External(size_t size, NRT_ExternalAllocator *allocator);
+
+/*
+ * Deallocate memory pointed by `ptr`.
+ */
+VISIBILITY_HIDDEN void NRT_Free(void *ptr);
+
+/*
+ * Reallocate memory at `ptr`.
+ */
+VISIBILITY_HIDDEN void *NRT_Reallocate(void *ptr, size_t size);
+
+/*
+ * Debugging printf function used internally
+ */
+VISIBILITY_HIDDEN void nrt_debug_print(const char *fmt, ...);
+
+/*
+ * Get API function table.
+ */
+VISIBILITY_HIDDEN const NRT_api_functions* NRT_get_api(void);
+
+
+/*
+ * FOR INTERNAL USE ONLY.
+ * Get a sample external allocator for testing
+ */
+VISIBILITY_HIDDEN NRT_ExternalAllocator* _nrt_get_sample_external_allocator(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* NUMBA_NRT_H_ */
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.py b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8551002a5f6af232ffa2bf40e62235d9e314676
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt.py
@@ -0,0 +1,131 @@
+from collections import namedtuple
+from weakref import finalize as _finalize
+
+from numba.core.runtime import nrtdynmod
+from llvmlite import binding as ll
+
+from numba.core.compiler_lock import global_compiler_lock
+from numba.core.typing.typeof import typeof_impl
+from numba.core import types, config
+from numba.core.runtime import _nrt_python as _nrt
+
+_nrt_mstats = namedtuple("nrt_mstats", ["alloc", "free", "mi_alloc", "mi_free"])
+
+
+class _Runtime(object):
+ def __init__(self):
+ self._init = False
+
+ @global_compiler_lock
+ def initialize(self, ctx):
+ """Initializes the NRT
+
+ Must be called before any actual call to the NRT API.
+ Safe to be called multiple times.
+ """
+ if self._init:
+ # Already initialized
+ return
+
+ # Switch stats on if the config requests them.
+ if config.NRT_STATS:
+ _nrt.memsys_enable_stats()
+
+ # Register globals into the system
+ for py_name in _nrt.c_helpers:
+ if py_name.startswith("_"):
+ # internal API
+ c_name = py_name
+ else:
+ c_name = "NRT_" + py_name
+ c_address = _nrt.c_helpers[py_name]
+ ll.add_symbol(c_name, c_address)
+
+ # Compile atomic operations
+ self._library = nrtdynmod.compile_nrt_functions(ctx)
+ self._init = True
+
+ def _init_guard(self):
+ if not self._init:
+ msg = "Runtime must be initialized before use."
+ raise RuntimeError(msg)
+
+ @staticmethod
+ def shutdown():
+ """
+ Shutdown the NRT
+ Safe to be called without calling Runtime.initialize first
+ """
+ _nrt.memsys_shutdown()
+
+ @property
+ def library(self):
+ """
+ Return the Library object containing the various NRT functions.
+ """
+ self._init_guard()
+ return self._library
+
+ def meminfo_new(self, data, pyobj):
+ """
+ Returns a MemInfo object that tracks memory at `data` owned by `pyobj`.
+ MemInfo will acquire a reference on `pyobj`.
+ The release of MemInfo will release a reference on `pyobj`.
+ """
+ self._init_guard()
+ mi = _nrt.meminfo_new(data, pyobj)
+ return MemInfo(mi)
+
+ def meminfo_alloc(self, size, safe=False):
+ """
+ Allocate a new memory of `size` bytes and returns a MemInfo object
+ that tracks the allocation. When there is no more reference to the
+ MemInfo object, the underlying memory will be deallocated.
+
+ If `safe` flag is True, the memory is allocated using the `safe` scheme.
+ This is used for debugging and testing purposes.
+ See `NRT_MemInfo_alloc_safe()` in "nrt.h" for details.
+ """
+ self._init_guard()
+ if size < 0:
+ msg = f"Cannot allocate a negative number of bytes: {size}."
+ raise ValueError(msg)
+ if safe:
+ mi = _nrt.meminfo_alloc_safe(size)
+ else:
+ mi = _nrt.meminfo_alloc(size)
+ if mi == 0: # alloc failed or size was 0 and alloc returned NULL.
+ msg = f"Requested allocation of {size} bytes failed."
+ raise MemoryError(msg)
+ return MemInfo(mi)
+
+ def get_allocation_stats(self):
+ """
+ Returns a namedtuple of (alloc, free, mi_alloc, mi_free) for count of
+ each memory operations.
+ """
+ # No init guard needed to access stats members
+ return _nrt_mstats(alloc=_nrt.memsys_get_stats_alloc(),
+ free=_nrt.memsys_get_stats_free(),
+ mi_alloc=_nrt.memsys_get_stats_mi_alloc(),
+ mi_free=_nrt.memsys_get_stats_mi_free())
+
+
+# Alias to _nrt_python._MemInfo
+MemInfo = _nrt._MemInfo
+
+
+@typeof_impl.register(MemInfo)
+def typeof_meminfo(val, c):
+ return types.MemInfoPointer(types.voidptr)
+
+
+# Create runtime
+_nrt.memsys_use_cpython_allocator()
+rtsys = _Runtime()
+
+# Install finalizer
+_finalize(rtsys, _Runtime.shutdown)
+
+# Avoid future use of the class
+del _Runtime
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/nrt_external.h b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt_external.h
new file mode 100644
index 0000000000000000000000000000000000000000..8689550157b66bb8280db0056ece315d014b6209
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/nrt_external.h
@@ -0,0 +1,65 @@
+#ifndef NUMBA_NRT_EXTERNAL_H_
+#define NUMBA_NRT_EXTERNAL_H_
+
+#include
+
+typedef struct MemInfo NRT_MemInfo;
+
+typedef void NRT_managed_dtor(void *data);
+
+typedef void *(*NRT_external_malloc_func)(size_t size, void *opaque_data);
+typedef void *(*NRT_external_realloc_func)(void *ptr, size_t new_size, void *opaque_data);
+typedef void (*NRT_external_free_func)(void *ptr, void *opaque_data);
+
+struct ExternalMemAllocator {
+ NRT_external_malloc_func malloc;
+ NRT_external_realloc_func realloc;
+ NRT_external_free_func free;
+ void *opaque_data;
+};
+
+typedef struct ExternalMemAllocator NRT_ExternalAllocator;
+
+typedef struct {
+ /* Methods to create MemInfos.
+
+ MemInfos are like smart pointers for objects that are managed by the Numba.
+ */
+
+ /* Allocate memory
+
+ *nbytes* is the number of bytes to be allocated
+
+ Returning a new reference.
+ */
+ NRT_MemInfo* (*allocate)(size_t nbytes);
+ /* Allocates memory using an external allocator but still using Numba's MemInfo.
+ *
+ * NOTE: An externally provided allocator must behave the same way as C99
+ * stdlib.h's "malloc" function with respect to return value
+ * (including the behaviour that occurs when requesting an allocation
+ * of size 0 bytes).
+ */
+ NRT_MemInfo* (*allocate_external)(size_t nbytes, NRT_ExternalAllocator *allocator);
+
+ /* Convert externally allocated memory into a MemInfo.
+
+ *data* is the memory pointer
+ *dtor* is the deallocator of the memory
+ */
+ NRT_MemInfo* (*manage_memory)(void *data, NRT_managed_dtor dtor);
+
+ /* Acquire a reference */
+ void (*acquire)(NRT_MemInfo* mi);
+
+ /* Release a reference */
+ void (*release)(NRT_MemInfo* mi);
+
+ /* Get MemInfo data pointer */
+ void* (*get_data)(NRT_MemInfo* mi);
+
+} NRT_api_functions;
+
+
+
+#endif /* NUMBA_NRT_EXTERNAL_H_ */
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/nrtdynmod.py b/venv/lib/python3.10/site-packages/numba/core/runtime/nrtdynmod.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8cc1973d3f791ab398dec1b1d474d0fd4e13cf9
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/nrtdynmod.py
@@ -0,0 +1,215 @@
+"""
+Dynamically generate the NRT module
+"""
+
+
+from numba.core import config
+from numba.core import types, cgutils
+from llvmlite import ir, binding
+
+
+_word_type = ir.IntType(config.MACHINE_BITS)
+_pointer_type = ir.PointerType(ir.IntType(8))
+
+_meminfo_struct_type = ir.LiteralStructType([
+ _word_type, # size_t refct
+ _pointer_type, # dtor_function dtor
+ _pointer_type, # void *dtor_info
+ _pointer_type, # void *data
+ _word_type, # size_t size
+ ])
+
+
+incref_decref_ty = ir.FunctionType(ir.VoidType(), [_pointer_type])
+meminfo_data_ty = ir.FunctionType(_pointer_type, [_pointer_type])
+
+
+def _define_nrt_meminfo_data(module):
+ """
+ Implement NRT_MemInfo_data_fast in the module. This allows LLVM
+ to inline lookup of the data pointer.
+ """
+ fn = cgutils.get_or_insert_function(module, meminfo_data_ty,
+ "NRT_MemInfo_data_fast")
+ builder = ir.IRBuilder(fn.append_basic_block())
+ [ptr] = fn.args
+ struct_ptr = builder.bitcast(ptr, _meminfo_struct_type.as_pointer())
+ data_ptr = builder.load(cgutils.gep(builder, struct_ptr, 0, 3))
+ builder.ret(data_ptr)
+
+
+def _define_nrt_incref(module, atomic_incr):
+ """
+ Implement NRT_incref in the module
+ """
+ fn_incref = cgutils.get_or_insert_function(module, incref_decref_ty,
+ "NRT_incref")
+ # Cannot inline this for refcount pruning to work
+ fn_incref.attributes.add('noinline')
+ builder = ir.IRBuilder(fn_incref.append_basic_block())
+ [ptr] = fn_incref.args
+ is_null = builder.icmp_unsigned("==", ptr, cgutils.get_null_value(ptr.type))
+ with cgutils.if_unlikely(builder, is_null):
+ builder.ret_void()
+
+ word_ptr = builder.bitcast(ptr, atomic_incr.args[0].type)
+ if config.DEBUG_NRT:
+ cgutils.printf(builder, "*** NRT_Incref %zu [%p]\n", builder.load(word_ptr),
+ ptr)
+ builder.call(atomic_incr, [word_ptr])
+ builder.ret_void()
+
+
+def _define_nrt_decref(module, atomic_decr):
+ """
+ Implement NRT_decref in the module
+ """
+ fn_decref = cgutils.get_or_insert_function(module, incref_decref_ty,
+ "NRT_decref")
+ # Cannot inline this for refcount pruning to work
+ fn_decref.attributes.add('noinline')
+ calldtor = ir.Function(module,
+ ir.FunctionType(ir.VoidType(), [_pointer_type]),
+ name="NRT_MemInfo_call_dtor")
+
+ builder = ir.IRBuilder(fn_decref.append_basic_block())
+ [ptr] = fn_decref.args
+ is_null = builder.icmp_unsigned("==", ptr, cgutils.get_null_value(ptr.type))
+ with cgutils.if_unlikely(builder, is_null):
+ builder.ret_void()
+
+
+ # For memory fence usage, see https://llvm.org/docs/Atomics.html
+
+ # A release fence is used before the relevant write operation.
+ # No-op on x86. On POWER, it lowers to lwsync.
+ builder.fence("release")
+
+ word_ptr = builder.bitcast(ptr, atomic_decr.args[0].type)
+
+ if config.DEBUG_NRT:
+ cgutils.printf(builder, "*** NRT_Decref %zu [%p]\n", builder.load(word_ptr),
+ ptr)
+ newrefct = builder.call(atomic_decr,
+ [word_ptr])
+
+ refct_eq_0 = builder.icmp_unsigned("==", newrefct,
+ ir.Constant(newrefct.type, 0))
+ with cgutils.if_unlikely(builder, refct_eq_0):
+ # An acquire fence is used after the relevant read operation.
+ # No-op on x86. On POWER, it lowers to lwsync.
+ builder.fence("acquire")
+ builder.call(calldtor, [ptr])
+ builder.ret_void()
+
+
+# Set this to True to measure the overhead of atomic refcounts compared
+# to non-atomic.
+_disable_atomicity = 0
+
+
+def _define_atomic_inc_dec(module, op, ordering):
+ """Define a llvm function for atomic increment/decrement to the given module
+ Argument ``op`` is the operation "add"/"sub". Argument ``ordering`` is
+ the memory ordering. The generated function returns the new value.
+ """
+ ftype = ir.FunctionType(_word_type, [_word_type.as_pointer()])
+ fn_atomic = ir.Function(module, ftype, name="nrt_atomic_{0}".format(op))
+
+ [ptr] = fn_atomic.args
+ bb = fn_atomic.append_basic_block()
+ builder = ir.IRBuilder(bb)
+ ONE = ir.Constant(_word_type, 1)
+ if not _disable_atomicity:
+ oldval = builder.atomic_rmw(op, ptr, ONE, ordering=ordering)
+ # Perform the operation on the old value so that we can pretend returning
+ # the "new" value.
+ res = getattr(builder, op)(oldval, ONE)
+ builder.ret(res)
+ else:
+ oldval = builder.load(ptr)
+ newval = getattr(builder, op)(oldval, ONE)
+ builder.store(newval, ptr)
+ builder.ret(oldval)
+
+ return fn_atomic
+
+
+def _define_atomic_cas(module, ordering):
+ """Define a llvm function for atomic compare-and-swap.
+ The generated function is a direct wrapper of the LLVM cmpxchg with the
+ difference that the a int indicate success (1) or failure (0) is returned
+ and the last argument is a output pointer for storing the old value.
+
+ Note
+ ----
+ On failure, the generated function behaves like an atomic load. The loaded
+ value is stored to the last argument.
+ """
+ ftype = ir.FunctionType(ir.IntType(32), [_word_type.as_pointer(),
+ _word_type, _word_type,
+ _word_type.as_pointer()])
+ fn_cas = ir.Function(module, ftype, name="nrt_atomic_cas")
+
+ [ptr, cmp, repl, oldptr] = fn_cas.args
+ bb = fn_cas.append_basic_block()
+ builder = ir.IRBuilder(bb)
+ outtup = builder.cmpxchg(ptr, cmp, repl, ordering=ordering)
+ old, ok = cgutils.unpack_tuple(builder, outtup, 2)
+ builder.store(old, oldptr)
+ builder.ret(builder.zext(ok, ftype.return_type))
+
+ return fn_cas
+
+
+def _define_nrt_unresolved_abort(ctx, module):
+ """
+ Defines an abort function due to unresolved symbol.
+
+ The function takes no args and will always raise an exception.
+ It should be safe to call this function with incorrect number of arguments.
+ """
+ fnty = ctx.call_conv.get_function_type(types.none, ())
+ fn = ir.Function(module, fnty, name="nrt_unresolved_abort")
+ bb = fn.append_basic_block()
+ builder = ir.IRBuilder(bb)
+ msg = "numba jitted function aborted due to unresolved symbol"
+ ctx.call_conv.return_user_exc(builder, RuntimeError, (msg,))
+ return fn
+
+
+def create_nrt_module(ctx):
+ """
+ Create an IR module defining the LLVM NRT functions.
+ A (IR module, library) tuple is returned.
+ """
+ codegen = ctx.codegen()
+ library = codegen.create_library("nrt")
+
+ # Implement LLVM module with atomic ops
+ ir_mod = library.create_ir_module("nrt_module")
+
+ atomic_inc = _define_atomic_inc_dec(ir_mod, "add", ordering='monotonic')
+ atomic_dec = _define_atomic_inc_dec(ir_mod, "sub", ordering='monotonic')
+ _define_atomic_cas(ir_mod, ordering='monotonic')
+
+ _define_nrt_meminfo_data(ir_mod)
+ _define_nrt_incref(ir_mod, atomic_inc)
+ _define_nrt_decref(ir_mod, atomic_dec)
+
+ _define_nrt_unresolved_abort(ctx, ir_mod)
+
+ return ir_mod, library
+
+
+def compile_nrt_functions(ctx):
+ """
+ Compile all LLVM NRT functions and return a library containing them.
+ The library is created using the given target context.
+ """
+ ir_mod, library = create_nrt_module(ctx)
+
+ library.add_ir_module(ir_mod)
+ library.finalize()
+
+ return library
diff --git a/venv/lib/python3.10/site-packages/numba/core/runtime/nrtopt.py b/venv/lib/python3.10/site-packages/numba/core/runtime/nrtopt.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a6f56b09108d06ed4522ff259a9ee49c279fcfd
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/numba/core/runtime/nrtopt.py
@@ -0,0 +1,182 @@
+"""
+NRT specific optimizations
+"""
+import re
+from collections import defaultdict, deque
+from llvmlite import binding as ll
+from numba.core import cgutils
+
+_regex_incref = re.compile(r'\s*(?:tail)?\s*call void @NRT_incref\((.*)\)')
+_regex_decref = re.compile(r'\s*(?:tail)?\s*call void @NRT_decref\((.*)\)')
+_regex_bb = re.compile(
+ r'|'.join([
+ # unnamed BB is just a plain number
+ r'[0-9]+:',
+ # with a proper identifier (see llvm langref)
+ r'[\'"]?[-a-zA-Z$._0-9][-a-zA-Z$._0-9]*[\'"]?:',
+ # is a start of a function definition
+ r'^define',
+ # no name
+ r'^;\s*
+