o
    ۾i?                     @   sx  d Z ddlmZ ddlmZ ddlZddlZddlmZ ddl	m
Z
mZmZ ddlmZmZ edd	d
gZeddZedZedZeZdd ZedZedZedZedZdZeeZG dd deZG dd deZG dd deZ dZ!dZ"dZ#dZ$dZ%e&eeeeegZ'e(e'Z)G dd deZ*G d d! d!eZ+G d"d# d#e+Z,G d$d% d%e+Z-e,e-d&Z.d'd( Z/dS ))z3
Calling conventions for Numba-compiled functions.
    )
namedtuple)IterableN)ir)typescgutilserrors)PYOBJECTGENERIC_POINTER	TryStatusin_tryexcinfoStatus)codeis_okis_noneis_erroris_stop_iterationis_python_excis_user_exc
excinfoptr    @   c                 C   s   t t| S N)r   Constant	errcode_t)r    r   G/home/ubuntu/.local/lib/python3.10/site-packages/numba/core/callconv.py
_const_int+      r      c                   @   sl   e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd Zdd Zdd Zdd ZdS )BaseCallConvc                 C   
   || _ d S r   )context)selfr%   r   r   r   __init__<      
zBaseCallConv.__init__c                 C   s   |t jkr| | d S ||krL| jj|||d}t||j}|| | j	||j
|j}| || W d    n1 s@w   Y  | | d S t|t jss||j
krb| jj||||j
d}| j	||j
|}| || d S td||)N)value)fromtytotyzreturning {0} for {1})r   nonereturn_native_noner%   make_helperr   as_bool_bitvalidif_thenget_return_valuetypedatareturn_value
isinstanceOptionalcastNotImplementedErrorformat)r&   builderrettyvaltyr)   optvalvalidbitretvalr   r   r   return_optional_value?   s,   

z"BaseCallConv.return_optional_valuec                 C      |  |t d S r   )_return_errcode_rawRETCODE_NONEr&   r;   r   r   r   r-   \      zBaseCallConv.return_native_nonec                 C   rB   r   )rC   RETCODE_EXCrE   r   r   r   
return_exc_   rF   zBaseCallConv.return_excc                 C   rB   r   )rC   RETCODE_STOPITrE   r   r   r   return_stop_iterationb   rF   z"BaseCallConv.return_stop_iterationc                 C   s   | j j|  }| S )zQ
        Get the actual type of the return argument for Numba type *ty*.
        )r%   data_model_managerget_return_type
as_pointer)r&   tyrestyper   r   r   rL   e   s   zBaseCallConv.get_return_typec                 C   s   |  |}||_|S )zS
        Initialize and return a call helper object for the given builder.
        )_make_call_helper_BaseCallConv__call_helper)r&   r;   chr   r   r   init_call_helperl   s   
zBaseCallConv.init_call_helperc                 C   s   |j S r   )rQ   rE   r   r   r   _get_call_helpert      zBaseCallConv._get_call_helperc                 C   s   | |jS r   )unserializer   )r&   r;   pyapistatusr   r   r   unpack_exceptionw   r   zBaseCallConv.unpack_exceptionc              	   C   s.  |j  }||j7 |  | |||}t|t|| |	| W d   n1 s1w   Y  |
| W d   n1 sEw   Y  ||j |d |
| W d   n1 sew   Y  ||j |
| W d   n1 sw   Y  |dd |
| || dS )zT
        Given a non-ok *status*, raise the corresponding Python exception.
        NPyExc_StopIterationPyExc_SystemErrorz*unknown error when calling native function)functionappend_basic_blockr1   r   	err_clearrY   r   	if_likelyis_not_nullraise_objectbranchr   err_set_noner   err_set_stringposition_at_end)r&   r;   rW   rX   bbendexcr   r   r   raise_errorz   s.   




zBaseCallConv.raise_errorc                 C   s    |  |}| |}|||S )z
        Get the decoded (unpacked) Python arguments with *argtypes*
        from LLVM function *func*.  A tuple of LLVM values is returned.
        )get_arguments_get_arg_packerfrom_arguments)r&   r;   argtypesfuncraw_argsarginfor   r   r   decode_arguments   s   

zBaseCallConv.decode_argumentsc                 C   s   | j |S )zF
        Get an argument packer for the given argument types.
        )r%   get_arg_packer)r&   rl   r   r   r   rj      s   zBaseCallConv._get_arg_packerN)__name__
__module____qualname__r'   rA   r-   rH   rJ   rL   rS   rT   rY   rh   rp   rj   r   r   r   r   r#   :   s    	r#   c                   @   sh   e Zd ZdZdd Zdd Z		dddZd	d
 Zdd Zdd Z	dd Z
dddZdd Zdd ZdS )MinimalCallConva  
    A minimal calling convention, suitable for e.g. GPU targets.
    The implemented function signature is:

        retcode_t (<Python return type>*, ... <Python arguments>)

    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).
    c                 C   s   t  S r   )_MinimalCallHelperrE   r   r   r   rP      rU   z!MinimalCallConv._make_call_helperc                 C   sP   |j jd }|j|jjksJ t|jt|jjf||| | |t d S Nr   )r\   argsr3   pointeestrstorerC   
RETCODE_OKr&   r;   r@   retptrr   r   r   r5         zMinimalCallConv.return_valueNc           
      C   s   |d urt |tstd|f |d ur t|ts td|f |d ur<| }|d u r.|}||j|jf}d |v r;d }nd }| |}|	|||}	| 
|t|	 d S )N-exc should be None or exception class, got %r(exc_args should be None or tuple, got %r)
issubclassBaseException	TypeErrorr6   tuple_raw_function_namefilenamelinerT   _add_exceptionrC   r   )
r&   r;   rg   exc_argsloc	func_namefnamelocinfocall_helperexc_idr   r   r   return_user_exc   s(   
zMinimalCallConv.return_user_excc                 C   s   |  ||j d S r   )rC   r   )r&   r;   rX   r   r   r   return_status_propagate   s   z'MinimalCallConv.return_status_propagatec                 C   s    t |tr	t|}|| d S r   )r6   intr   retr&   r;   r   r   r   r   rC      s   
z#MinimalCallConv._return_errcode_rawc              
   C   sx   | d|t}| d|t}|||}||}| d|t}| d|t}| d|t}	t||||||	|dd}
|
S )z?
        Given a return *code*, get a Status instance.
        ==>=Nr   r   r   r   r   r   r   r   )	icmp_signedr|   rD   or_not_rG   rI   RETCODE_USEREXCr   )r&   r;   r   normr,   okerrrg   r   r   rX   r   r   r   _get_return_status   s"   
z"MinimalCallConv._get_return_statusc                 C   s4   |  |}t|j}| |}tt|g| }|S zQ
        Get the implemented Function type for *restype* and *argtypes*.
        )rj   listargument_typesrL   r   FunctionTyper   r&   rO   rl   ro   resptrfntyr   r   r   get_function_type   s
   


z!MinimalCallConv.get_function_typeFc                 C   s>   |rJ |  |}|| |dd |D  d|jd _dS )zA
        Set names and attributes of function arguments.
        c                 S      g | ]}d | qS zarg.r   .0ar   r   r   
<listcomp>	      z5MinimalCallConv.decorate_function.<locals>.<listcomp>z.retr   N)rj   assign_namesri   rx   name)r&   fnrx   fe_argtypesnoaliasro   r   r   r   decorate_function  s   
z!MinimalCallConv.decorate_functionc                 C      |j dd S )@
        Get the Python-level arguments of LLVM *func*.
        r"   Nrx   r&   rm   r   r   r   ri        zMinimalCallConv.get_argumentsc                 C   s   |j d jj}t||}|t|| | |}|||}|gt	| }	|
||	}
| ||
}||}| j|||}||fS )z3
        Call the Numba-compiled *callee*.
        r   )rx   r3   ry   r   alloca_oncer{   get_null_valuerj   as_argumentsr   callr   loadr%   get_returned_value)r&   r;   calleerestyargtysrx   r<   	retvaltmpro   realargsr   rX   r@   outr   r   r   call_function  s   

zMinimalCallConv.call_functionNNNF)rr   rs   rt   __doc__rP   r5   r   r   rC   r   r   r   ri   r   r   r   r   r   ru      s    



ru   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	rv   z
    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.
    c                 C   s
   i | _ d S r   )
exceptionsr&   r   r   r   r'   ,  r(   z_MinimalCallHelper.__init__c                 C   s"   t | jt }|||f| j|< |S )aV  
        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
        )lenr   FIRST_USEREXC)r&   rg   r   r   r   r   r   r   r   /  s   z!_MinimalCallHelper._add_exceptionc                 C   s@   z| j | W S  ty   d| }t}|f}d}|||f Y S w )z
        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
        z#unknown error %d in native functionN)r   KeyErrorSystemError)r&   r   msgrg   r   r   r   r   r   get_exceptionA  s   
z _MinimalCallHelper.get_exceptionN)rr   rs   rt   r   r'   r   r   r   r   r   r   rv   %  s
    rv            c                   @   s   e Zd ZdZedZdd Zdd Zdd Z					d5d
dZ
				d5ddZdd Zdd Zdd Zdd Z				d6ddZ		d6ddZdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd7d+d,Zd-d. Zd/d0 Zd1d2 Z		d8d3d4Zd	S )9CPUCallConva  
    The calling convention for CPU targets.
    The implemented function signature is:

        retcode_t (<Python return type>*, excinfo **, ... <Python arguments>)

    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).
    r"   c                 C   s   d S r   r   rE   r   r   r   rP   r  s   zCPUCallConv._make_call_helperc                 C   sP   |  |j}|j|jjksJ t|jt|jjf||| | |t d S r   )_get_return_argumentr\   r3   ry   rz   r{   rC   r|   r}   r   r   r   r5   u  r   zCPUCallConv.return_valuec                 C   sJ   |d ur|  }|d u r|}||j|jf}d |v rd }nd }|||f}|S r   )r   r   r   )r&   rg   r   r   r   r   r   r   r   r   build_excinfo_struct|  s   
z CPUCallConv.build_excinfo_structNc                 C   s   |d urt |tstd|f |d ur t|ts td|f |d u r't }| j|}| ||||}||}| 	|j
}|||}	|jtddg}
|	d|
 d S )Nr   r   r"   numba_exception_output)r   r   r   r6   r   r%   get_python_apir   serialize_object_get_excinfo_argumentr\   r{   moduleadd_metadatar   IntTypeset_metadata)r&   r;   rg   r   r   r   rW   	struct_gvexcptrr{   mdr   r   r   set_static_user_exc  s"   %
zCPUCallConv.set_static_user_excc                 C   sP   t |dd}| j|||||d | | |r ||d  d S | |t d S )N_in_try_blockF)r   r   r   target)getattrr   check_try_statusrb   rC   r   )r&   r;   rg   r   r   r   try_infor   r   r   r     s   

zCPUCallConv.return_user_excc                 C   s<  |j }|||t}|||t}|||||j}|||t}|||t	}	t
ttg}
||	|
 }|||g}t||}t||) d}|d| |jj}
t|
jt
jsr|t|
j n|  W d    n1 sw   Y  |||}| jjr| jj !||||j" |S )Nz<Error creating Python tuple from runtime exception argumentsPyExc_RuntimeError)#r   extract_valuer   PICKLE_BUF_IDXPICKLE_BUFSZ_IDXbytes_from_string_and_sizesext
py_ssize_tHASH_BUF_IDXUNWRAP_FUNC_IDXr   r   r   r	   bitcastrM   r   r   is_nullif_unlikelyrd   r\   function_typer6   return_typeVoidTyper   r   ret_voidbuild_dynamic_excinfo_structr%   
enable_nrtnrtfreevoidptr)r&   r;   rW   rX   excinfo_ptr	picklebufpicklebuf_szstatic_exc_bytesdyn_argsfunc_ptrr   r   py_tuplefailedr   r   r   r   r   unpack_dynamic_exception  sF   



z$CPUCallConv.unpack_dynamic_exceptionc              	   C   s   |j }|||t}|d|td}||@\}}| | |||}	|j}
W d    n1 s4w   Y  | |	|}|j}W d    n1 sNw   Y  W d    n1 s]w   Y  |
|j}||	|
 ||| |S )N>r   )r   r   r   ALLOC_FLAG_IDXr   int32_tif_elser  blockrV   phir3   add_incoming)r&   r;   rW   rX   r   
alloc_flaggtthen	otherwisedyn_excbb_then
static_excbb_elser  r   r   r   rY     s(   
zCPUCallConv.unpack_exceptionc                 C   sZ  t t|  }d| }||jv r|j|S tt	t	g}t
|||}|jd |jd |d}t|}	| j|	}
| }|	|jd |}dd |D }g }| jj|	dd	}t|D ]-\}}|	|	||}|
j|||d
}|t|jkrd| d}t||| qg| jj |	| !|	j" |
#|}|	$| |S )N__excinfo_unwrap_argsnounwindnoinline r   c                 S   s   g | ]}|d ur|qS r   r   )r   typr   r   r   r   D  s    z@CPUCallConv.emit_unwrap_dynamic_exception_fn.<locals>.<listcomp>T)return_pyobject)env_managerzCannot convert native z to a Python object.)%hashlibsha1rz   encode	hexdigestglobalsgetr   r   r	   Function
attributesaddr]   	IRBuilderr%   r   rM   r   rx   get_env_manager	enumerater   r   from_native_valuer   r   r3   r   TypingErrorappendr   r   r   r\   
tuple_packr   )r&   r   st_typenb_types_hashr   r   r   bb_entryr;   rW   st_type_ptrst_ptrobjsr  ir  valobjr   tupr   r   r    emit_unwrap_dynamic_exception_fn   s>   








z,CPUCallConv.emit_unwrap_dynamic_exception_fnc           
   
   C   sv   | | j|}|| jj||| }dd |D }td}t|D ]\}}	|	|	|
||t|g q&|S )zP
        Create an anonymous struct containing the given LLVM *values*.
        c                 S   s   g | ]
}t |tjr|qS r   r6   r   Valuer   argr   r   r   r   k  s    z4CPUCallConv.emit_wrap_args_insts.<locals>.<listcomp>r   )r   r%   get_abi_sizeofr   r   allocaterM   r
  r)  r{   gep)
r&   r;   rW   struct_typer   st_sizer3  zeroidxr=  r   r   r   emit_wrap_args_insts`  s   z CPUCallConv.emit_wrap_args_instsc              
      sj  t |tstd|f |durt|tstd|f | j|}| j  t fdd|D }| ||||}| 	|j
}	|||}
tdd |D }| ||||}| |j||}|| jt}|| jj||t}td}||
t||
t||t||ttt|f}t|D ]\}}| ||!||t|g q| ||	 dS )zf
        Compute the required bits to emit an exception with dynamic (runtime)
        values
        z(exc should be an exception class, got %rNr   c                    s    g | ]}t |tjr n|qS r   r:  r<  dummyr   r   r     s     z4CPUCallConv.set_dynamic_user_exc.<locals>.<listcomp>c                 S   s   g | ]}t |tjr|jqS r   )r6   r   r;  r3   r<  r   r   r   r     s    
r   )"r   r   r   r6   r   r%   r   get_dummy_valuer   r   r\   r   r   r   LiteralStructTyperE  r9  r   r   r>  	excinfo_tr   r   r?  excinfo_ptr_tr
  r   r   r   r	   r   r)  r{   r@  )r&   r;   rg   r   r/  r   r   rW   exc_args_static
excinfo_ppr   rA  r3  	unwrap_fnexc_size	excinfo_prC  
exc_fieldsrD  r=  r   rF  r   set_dynamic_user_excs  sL   
1






z CPUCallConv.set_dynamic_user_excc                 C   s&   | j ||||||d | |t dS )zF
        Same as ::return_user_exc but for dynamic exceptions
        )r   r   N)rR  rC   r   )r&   r;   rg   r   r/  r   r   r   r   r   return_dynamic_user_exc  s   z#CPUCallConv.return_dynamic_user_excc              	   C   s:   z|j W S  ty   tj|tjddd}||_ | Y S w )N	try_stateT)r   zfill)_CPUCallConv__eh_try_stateAttributeErrorr   r   intp_t)r&   r;   ptrr   r   r   _get_try_state  s   
zCPUCallConv._get_try_statec                 C   sJ   |  |}||}|d||d}| |j}||}t||dS )Nr  r   )r   r   )rZ  r   icmp_unsignedr3   r   r\   r
   )r&   r;   try_state_ptr	try_depthr   r   r   r   r   r   r     s   


zCPUCallConv.check_try_statusc                 C   s6   |  |}||}|||d}||| d S Nr"   )rZ  r   r&  r3   r{   )r&   r;   r\  oldnewr   r   r   set_try_status  s   

zCPUCallConv.set_try_statusc                 C   s\   |  |}||}|||d}||| | |j}t|jj	}||| d S r^  )
rZ  r   subr3   r{   r   r\   r   r   ry   )r&   r;   r\  r_  r`  r   nullr   r   r   unset_try_status  s   

zCPUCallConv.unset_try_statusc                 C   sj   |  |}| |j}||j| |||j | ||j	 W d    d S 1 s.w   Y  d S r   )
r   r   r\   r{   r   r1   r   r   rC   r   )r&   r;   rX   	trystatusr   r   r   r   r     s   
"z#CPUCallConv.return_status_propagatec                 C   s   | | d S r   )r   r   r   r   r   rC   	  s   zCPUCallConv._return_errcode_rawc              
   C   s   | d|t}| d|t}| d|t}| d|t}|||}||}	| d|t}
||
|t	
tt	j}t|||	|||
||d}|S )zP
        Given a return *code* and *excinfoptr*, get a Status instance.
        r   r   r   )r   r|   rD   rG   rI   r   r   r   selectr   r   rK  	Undefinedr   )r&   r;   r   r   r   r,   rg   r   r   r   r   rX   r   r   r   r     s(   
zCPUCallConv._get_return_statusc                 C   s<   |  |}t|j}| |}tt|ttg| }|S r   )	rj   r   r   rL   r   r   r   PointerTyperK  r   r   r   r   r   $  s   


zCPUCallConv.get_function_typeFc                    s     |}| |dd |D   |}d|_|d |d  |}d|_|d |d |rT |}|D ]}t|jt	j
rS|d |d q@ fdd}	tt|	|}
|
ru|jd	}||j|g d
S d
S )zU
        Set names of function arguments, and add useful attributes to them.
        c                 S   r   r   r   r   r   r   r   r   6  r   z1CPUCallConv.decorate_function.<locals>.<listcomp>r~   	nocapturer   r   c                    s(   t | tjs jj}||   rdS dS NTF)r6   r   Arrayr%   rK   contains_nrt_meminfo)rN   dmmr   r   r   type_may_always_need_nrtI  s
   z?CPUCallConv.decorate_function.<locals>.type_may_always_need_nrtnumba_args_may_always_need_nrtN)rj   r   ri   r   r   add_attributer   r6   r3   r   rh  anymapr   add_named_metadatar&  r   )r&   r   rx   r   r   ro   retargexcargr   rn  args_may_always_need_nrtnmdr   r   r   r   0  s:   









zCPUCallConv.decorate_functionc                 C   r   )r   r   Nr   r   r   r   r   ri   [  r   zCPUCallConv.get_argumentsc                 C   
   |j d S rw   r   r   r   r   r   r   a  r(   z CPUCallConv._get_return_argumentc                 C   rx  r^  r   r   r   r   r   r   d  r(   z!CPUCallConv._get_excinfo_argumentc                 C   s  |  |j}| |jj}||krd| d| }	t|	t||}
|t||
 tj|t	
tdd}| |}t|||}|
|g| }|du rQd}nt|tr`t|ts`t|}ntd|j|||d}| ||||}||
}| j|||}||fS )	aU  
        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")
        zFunction type returns z but resty=r   )r   Nr   z,attrs must be an iterable of strings or None)attrs)rL   ry   r   r   
ValueErrorr   r   r{   r   r   rh  rJ  rj   r   r   r6   r   rz   r   r   r   r   r   r%   r   )r&   r;   r   r   r   rx   ry  r<   actual_rettymr   r   ro   r   _attrsr   rX   r@   r   r   r   r   r   g  s2   


zCPUCallConv.call_functionr   NNr   r   )rr   rs   rt   r   	itertoolscount_status_idsrP   r5   r   r   r   r  rY   r9  rE  rR  rS  rZ  r   ra  rd  r   rC   r   r   r   ri   r   r   r   r   r   r   r   r   a  sF    

9
4@
^
	

+r   c                   @   s   e Zd Zdd ZdddZdS )
ErrorModelc                 C   r$   r   )	call_conv)r&   r  r   r   r   r'     r(   zErrorModel.__init__Nc                 C   s    | j r| j|t|| dS dS rj  )raise_on_fp_zero_divisionr  r   ZeroDivisionError)r&   r;   r   r   r   r   r   fp_zero_division  s   zErrorModel.fp_zero_divisionr~  )rr   rs   rt   r'   r  r   r   r   r   r    s    r  c                   @      e Zd ZdZdZdS )PythonErrorModelzL
    The Python error model.  Any invalid FP input raises an exception.
    TNrr   rs   rt   r   r  r   r   r   r   r    s    r  c                   @   r  )NumpyErrorModela6  
    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
    FNr  r   r   r   r   r    s    r  )pythonnumpyc                 C   s   t |  |jS )zF
    Create an error model instance for the given target context.
    )error_modelsr  )
model_namer%   r   r   r   create_error_model  r   r  )0r   collectionsr   collections.abcr   r  r  llvmliter   
numba.corer   r   r   numba.core.baser   r	   r
   r   r   r
  int64_tr   r   r|   rG   rD   rI   r   r   objectr#   ru   rv   r   r   r   r   r	  rI  rJ  rh  rK  r   r  r  r  r  r  r   r   r   r   <module>   s\    

n}2
    6