U
    |e~                     @   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   P/var/www/website-v5/atlas_env/lib/python3.8/site-packages/numba/core/callconv.py
_const_int+   s    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   s
   || _ d S r   )context)selfr#   r   r   r   __init__<   s    zBaseCallConv.__init__c              	   C   s   |t jkr| | n||kr| jj|||d}t||j}||& | j	||j
|j}| || W 5 Q R X | | n\t|t js||j
kr| jj||||j
d}| j	||j
|}| || ntd||d S )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&   ZoptvalZvalidbitretvalr   r   r   return_optional_value?   s*    

z"BaseCallConv.return_optional_valuec                 C   s   |  |t d S r   )_return_errcode_rawRETCODE_NONEr$   r8   r   r   r   r*   \   s    zBaseCallConv.return_native_nonec                 C   s   |  |t d S r   )r=   RETCODE_EXCr?   r   r   r   
return_exc_   s    zBaseCallConv.return_excc                 C   s   |  |t d S r   )r=   RETCODE_STOPITr?   r   r   r   return_stop_iterationb   s    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   rE   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$   r8   chr   r   r   init_call_helperl   s    
zBaseCallConv.init_call_helperc                 C   s   |j S r   )rJ   r?   r   r   r   _get_call_helpert   s    zBaseCallConv._get_call_helperc                 C   s   | |jS r   )unserializer   )r$   r8   pyapistatusr   r   r   unpack_exceptionw   s    zBaseCallConv.unpack_exceptionc              
   C   s   |j  }||jP |  | |||}t|t|| |	| W 5 Q R X |
| W 5 Q R X ||j |d |
| W 5 Q R X ||j |
| W 5 Q R X |dd |
| || dS )zT
        Given a non-ok *status*, raise the corresponding Python exception.
        ZPyExc_StopIterationZPyExc_SystemErrorz*unknown error when calling native functionN)functionappend_basic_blockr.   r   	err_clearrQ   r   	if_likelyis_not_nullraise_objectbranchr   err_set_noner   err_set_stringposition_at_end)r$   r8   rO   rP   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$   r8   argtypesfuncZ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#   Zget_arg_packer)r$   rb   r   r   r   r`      s    zBaseCallConv._get_arg_packerN)__name__
__module____qualname__r%   r<   r*   rA   rC   rE   rL   rM   rQ   r^   re   r`   r   r   r   r   r"   :   s   	r"   c                   @   sd   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   )_MinimalCallHelperr?   r   r   r   rI      s    z!MinimalCallConv._make_call_helperc                 C   sP   |j jd }|j|jjks4tt|jt|jjf||| | |t d S Nr   )	rR   argsr0   pointeeAssertionErrorstrstorer=   
RETCODE_OKr$   r8   r;   retptrr   r   r   r2      s    zMinimalCallConv.return_valueNc           
      C   s   |d k	r t |ts td|f |d k	r@t|ts@td|f |d k	rx| }|d kr\|}||j|jf}d |k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	TypeErrorr3   tuple_raw_function_namefilenamelinerM   _add_exceptionr=   r   )
r$   r8   r]   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   )r=   r   )r$   r8   rP   r   r   r   return_status_propagate   s    z'MinimalCallConv.return_status_propagatec                 C   s    t |trt|}|| d S r   )r3   intr   retr$   r8   r   r   r   r   r=      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_signedrq   r>   or_not_r@   rB   RETCODE_USEREXCr   )r$   r8   r   normr)   okerrr]   r   r   rP   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*.
        )r`   listargument_typesrE   r   FunctionTyper   r$   rH   rb   rd   resptrfntyr   r   r   get_function_type   s
    


z!MinimalCallConv.get_function_typeFc                 C   s>   |rt | |}|| |dd |D  d|jd _|S )zA
        Set names and attributes of function arguments.
        c                 S   s   g | ]}d | qS zarg.r   .0ar   r   r   
<listcomp>	  s     z5MinimalCallConv.decorate_function.<locals>.<listcomp>z.retr   )rn   r`   assign_namesr_   rl   name)r$   fnrl   fe_argtypesnoaliasrd   r   r   r   decorate_function  s    
z!MinimalCallConv.decorate_functionc                 C   s   |j dd S )@
        Get the Python-level arguments of LLVM *func*.
        r!   Nrl   r$   rc   r   r   r   r_     s    zMinimalCallConv.get_argumentsc                 C   s   |j d jj}t||}|t|| | |}|||}|gt	| }	|
||	}
| ||
}||}| j|||}||fS )z3
        Call the Numba-compiled *callee*.
        r   )rl   r0   rm   r   alloca_oncerp   get_null_valuer`   as_argumentsr   callr   loadr#   get_returned_value)r$   r8   calleerestyargtysrl   r9   	retvaltmprd   realargsr   rP   r;   outr   r   r   call_function  s    

zMinimalCallConv.call_function)NNN)F)rf   rg   rh   __doc__rI   r2   r   r   r=   r   r   r   r_   r   r   r   r   r   ri      s     


ri   c                   @   s(   e Zd ZdZdd Zdd Zdd ZdS )	rj   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%   -  s    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$   r]   r~   r   r   r   r   r   r}   0  s    z!_MinimalCallHelper._add_exceptionc                 C   sF   z| j | W S  tk
r@   d| }t}|f}d}|||f Y S X dS )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   msgr]   r~   r   r   r   r   get_exceptionB  s    
z _MinimalCallHelper.get_exceptionN)rf   rg   rh   r   r%   r}   r   r   r   r   r   rj   &  s   rj            c                   @   s   e Zd ZdZedZdd Zdd Zdd Z	d5d
dZ
d6ddZdd Zdd Zdd Zdd Zd7ddZd8d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d9d+d,Zd-d. Zd/d0 Zd1d2 Zd:d3d4Zd	S );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   r?   r   r   r   rI   s  s    zCPUCallConv._make_call_helperc                 C   sP   |  |j}|j|jjks4tt|jt|jjf||| | |t d S r   )	_get_return_argumentrR   r0   rm   rn   ro   rp   r=   rq   rr   r   r   r   r2   v  s    zCPUCallConv.return_valuec                 C   sJ   |d k	r8|  }|d kr|}||j|jf}d |kr<d }nd }|||f}|S r   )rz   r{   r|   )r$   r]   r~   r   r   r   r   r   r   r   build_excinfo_struct}  s    
z CPUCallConv.build_excinfo_structNc                 C   s   |d k	r t |ts td|f |d k	r@t|ts@td|f |d krNt }| j|}| ||||}||}| 	|j
}|||}	|jtddg}
|	d|
 d S )Nrt   ru   r!   Znumba_exception_output)rv   rw   rx   r3   ry   r#   get_python_apir   serialize_object_get_excinfo_argumentrR   rp   moduleadd_metadatar   IntTypeset_metadata)r$   r8   r]   r~   r   r   rO   	struct_gvexcptrrp   mdr   r   r   set_static_user_exc  s"    %
zCPUCallConv.set_static_user_excc                 C   sN   t |dd}| j|||||d | | |r>||d  n| |t d S )N_in_try_blockF)r~   r   r   target)getattrr   check_try_statusrX   r=   r   )r$   r8   r]   r~   r   r   Z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||H d}|d| |jj}
t|
jt
js|t|
j n|  W 5 Q R X |||}| 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	   bitcastrF   r   r   is_nullif_unlikelyrZ   rR   function_typer3   return_typeVoidTyper   r   ret_voidbuild_dynamic_excinfo_structr#   
enable_nrtnrtfreevoidptr)r$   r8   rO   rP   excinfo_ptrZ	picklebufZpicklebuf_szZstatic_exc_bytesZdyn_argsfunc_ptrr   r   Zpy_tuplefailedr   r   r   r   r   unpack_dynamic_exception  sN         
 z$CPUCallConv.unpack_dynamic_exceptionc              
   C   s   |j }|||t}|d|td}||N\}}| | |||}	|j}
W 5 Q R X | |	|}|j}W 5 Q R X W 5 Q R X |
|j}||	|
 ||| |S )N>r   )r   r   r   ALLOC_FLAG_IDXr   int32_tif_elser   blockrN   phir0   add_incoming)r$   r8   rO   rP   r   Z
alloc_flaggtthen	otherwiseZdyn_excZbb_then
static_excZbb_elser   r   r   r   rQ   	  s     
zCPUCallConv.unpack_exceptionc                 C   s\  t t|  }d| }||jkr6|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r d| d}t||| q| jj |	| !|	j" |
#|}|	$| |S )NZ__excinfo_unwrap_argsnounwindnoinline r   c                 S   s   g | ]}|d k	r|qS r   r   )r   typr   r   r   r   E  s      z@CPUCallConv.emit_unwrap_dynamic_exception_fn.<locals>.<listcomp>T)return_pyobject)env_managerzCannot convert native z to a Python object.)%hashlibsha1ro   encode	hexdigestglobalsgetr   r   r	   Function
attributesaddrS   	IRBuilderr#   r   rF   r   rl   get_env_manager	enumerater   r   from_native_valuer   r   r0   r   TypingErrorappendr   r   r   rR   
tuple_packr   )r$   r   Zst_typenb_types_hashr   r   r   Zbb_entryr8   rO   Z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 qL|S )zP
        Create an anonymous struct containing the given LLVM *values*.
        c                 S   s   g | ]}t |tjr|qS r   )r3   r   Valuer   argr   r   r   r   l  s      z4CPUCallConv.emit_wrap_args_insts.<locals>.<listcomp>r   )r   r#   get_abi_sizeofr   r   allocaterF   r   r  rp   gep)
r$   r8   rO   struct_typer~   st_sizer  zeroidxr  r   r   r   emit_wrap_args_instsa  s    z CPUCallConv.emit_wrap_args_instsc              
   C   sL  t |tstd|f |dk	r8t|ts8td|f | j|}| ||||}| |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 %rNru   c                 S   s   g | ]}t |tjr|jqS r   )r3   r   r  r0   r  r   r   r   r     s    z4CPUCallConv.set_dynamic_user_exc.<locals>.<listcomp>r   )!rv   rw   rx   r3   ry   r#   r   r   r   rR   r   r   r   LiteralStructTyper#  r  r   r   r  	excinfo_tr   r   r  excinfo_ptr_tr   r   r   r   r	   r   r  rp   r  )r$   r8   r]   r~   r  r   r   rO   Z
excinfo_ppr   r  r  Z	unwrap_fnZexc_sizeZ	excinfo_pr!  Z
exc_fieldsr"  r  r   r   r   set_dynamic_user_exct  sH    
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)r'  r=   r   )r$   r8   r]   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k
r:   tj|tjddd}||_ | Y S X d S )NZ	try_stateT)r   zfill)Z_CPUCallConv__eh_try_stateAttributeErrorr   r   intp_t)r$   r8   ptrr   r   r   _get_try_state  s       zCPUCallConv._get_try_statec                 C   sJ   |  |}||}|d||d}| |j}||}t||dS )Nr   r   )r   r   )r-  r   icmp_unsignedr0   r   rR   r
   )r$   r8   try_state_ptrZ	try_depthr   r   r   r   r   r   r     s    


zCPUCallConv.check_try_statusc                 C   s6   |  |}||}|||d}||| d S Nr!   )r-  r   r  r0   rp   )r$   r8   r/  oldnewr   r   r   set_try_status  s    

zCPUCallConv.set_try_statusc                 C   s\   |  |}||}|||d}||| | |j}t|jj	}||| d S r0  )
r-  r   subr0   rp   r   rR   r   r   rm   )r$   r8   r/  r1  r2  r   nullr   r   r   unset_try_status  s    

zCPUCallConv.unset_try_statusc              	   C   sT   |  |}| |j}||j| |||j | ||j	 W 5 Q R X d S r   )
r   r   rR   rp   r   r.   r   r   r=   r   )r$   r8   rP   Z	trystatusr   r   r   r   r      s
    
z#CPUCallConv.return_status_propagatec                 C   s   | | d S r   )r   r   r   r   r   r=     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   rq   r>   r@   rB   r   r   r   selectr   r   r&  	Undefinedr   )r$   r8   r   r   r   r)   r]   r   r   r   r   rP   r   r   r   r   
  s(    
zCPUCallConv._get_return_statusc                 C   s<   |  |}t|j}| |}tt|ttg| }|S r   )	r`   r   r   rE   r   r   r   PointerTyper&  r   r   r   r   r   "  s    


zCPUCallConv.get_function_typeFc                    s     |}| |dd |D   |}d|_|d |d  |}d|_|d |d |r |}|D ]&}t|jt	j
r|d |d q fdd}	tt|	|}
|
r|jd	}||j|g |S )
zU
        Set names of function arguments, and add useful attributes to them.
        c                 S   s   g | ]}d | qS r   r   r   r   r   r   r   4  s     z1CPUCallConv.decorate_function.<locals>.<listcomp>rs   	nocapturer   r   c                    s(   t | tjs$ jj}||   r$dS dS NTF)r3   r   Arrayr#   rD   contains_nrt_meminfo)rG   dmmr   r   r   type_may_always_need_nrtG  s
    z?CPUCallConv.decorate_function.<locals>.type_may_always_need_nrtnumba_args_may_always_need_nrt)r`   r   r_   r   r   add_attributer   r3   r0   r   r9  anymapr   add_named_metadatar  r   )r$   r   rl   r   r   rd   ZretargZexcargr   r?  Zargs_may_always_need_nrtnmdr   r   r   r   .  s8    








zCPUCallConv.decorate_functionc                 C   s   |j dd S )r   r   Nr   r   r   r   r   r_   [  s    zCPUCallConv.get_argumentsc                 C   s
   |j d S rk   r   r   r   r   r   r   a  s    z CPUCallConv._get_return_argumentc                 C   s
   |j d S r0  r   r   r   r   r   r   d  s    z!CPUCallConv._get_excinfo_argumentc                 C   s   |  |jj}t||}|t|| tj|tt	dd}	| 
|}
t|
||}||	g| }|dkrvd}n&t|trt|tst|}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")
        r   )r   Nr   z,attrs must be an iterable of strings or None)attrs)r   r   rm   r   r   rp   r   r   r9  r%  r`   r   r   r3   r   ro   ry   rx   r   r   r   r#   r   )r$   r8   r   r   r   rl   rF  r9   r   r   rd   r   Z_attrsr   rP   r;   r   r   r   r   r   g  s*    


zCPUCallConv.call_function)NNN)NNN)NN)NN)F)N)rf   rg   rh   r   	itertoolscountZ_status_idsrI   r2   r   r   r   r   rQ   r  r#  r'  r(  r-  r   r3  r6  r   r=   r   r   r   r_   r   r   r   r   r   r   r   r   b  sF   
  
9  
4@  
[   
	

- r   c                   @   s   e Zd Zdd ZdddZdS )
ErrorModelc                 C   s
   || _ d S r   )	call_conv)r$   rJ  r   r   r   r%     s    zErrorModel.__init__Nc                 C   s$   | j r| j|t|| dS dS d S r;  )raise_on_fp_zero_divisionrJ  r   ZeroDivisionError)r$   r8   r~   r   r   r   r   fp_zero_division  s    zErrorModel.fp_zero_division)NN)rf   rg   rh   r%   rM  r   r   r   r   rI    s   rI  c                   @   s   e Zd ZdZdZdS )PythonErrorModelzL
    The Python error model.  Any invalid FP input raises an exception.
    TNrf   rg   rh   r   rK  r   r   r   r   rN    s   rN  c                   @   s   e Zd ZdZdZdS )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
    FNrO  r   r   r   r   rP    s   rP  )pythonnumpyc                 C   s   t |  |jS )zF
    Create an error model instance for the given target context.
    )error_modelsrJ  )
model_namer#   r   r   r   create_error_model  s    rU  )0r   collectionsr   collections.abcr   rG  r   llvmliter   
numba.corer   r   r   Znumba.core.baser   r	   r
   r   r   r   int64_tr   r   rq   r@   r>   rB   r   r   objectr"   ri   rj   r   r   r   r   r   r$  r%  r9  r&  r   rI  rN  rP  rS  rU  r   r   r   r   <module>   sZ   

n~2
    3