B \ J@s.dZddlmZddlZddlmZddlmZmZddl m Z m Z edd Z e d ZeZd d ZedZed ZedZedZdZeeZGdddeZGdddeZGdddeZee egZeeZGdddeZGdddeZ Gddde Z!Gddde Z"e!e"dZ#dd Z$dS)!z3 Calling conventions for Numba-compiled functions. ) namedtupleN)ir)cgutilstypes)PYOBJECTGENERIC_POINTERStatus)codeis_okis_noneis_erroris_stop_iteration is_python_exc is_user_exc excinfoptr cCs tt|S)N)rConstant errcode_t)r r5lib/python3.7/site-packages/numba/targets/callconv.py _const_int#src@sdeZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ dS) BaseCallConvcCs ||_dS)N)context)selfrrrr__init__5szBaseCallConv.__init__c Cs|tjkr||n||kr|jj|||d}t||j}||&|j ||j |j }| ||WdQRX||n\t |tjs||j kr|jj||||j d}|j ||j |}| ||ntd||dS)N)value)ZfromtyZtotyzreturning {0} for {1})rnonereturn_native_nonerZ make_helperrZ as_bool_bitZvalidif_thenZget_return_valuetypedata return_value isinstanceZOptionalcastNotImplementedErrorformat)rbuilderrettyZvaltyrZoptvalZvalidbitretvalrrrreturn_optional_value8s$         z"BaseCallConv.return_optional_valuecCs||tdS)N)_return_errcode_raw RETCODE_NONE)rr*rrrr!UszBaseCallConv.return_native_nonecCs||tdS)N)r. RETCODE_EXC)rr*rrr return_excXszBaseCallConv.return_exccCs||tdS)N)r.RETCODE_STOPIT)rr*rrrreturn_stop_iteration[sz"BaseCallConv.return_stop_iterationcCs|jj|}|S)zQ Get the actual type of the return argument for Numba type *ty*. )rZdata_model_managerget_return_typeZ as_pointer)rZtyrestyperrrr4^szBaseCallConv.get_return_typecCs||}||_|S)zS Initialize and return a call helper object for the given builder. )_make_call_helper_BaseCallConv__call_helper)rr*Zchrrrinit_call_helperes zBaseCallConv.init_call_helpercCs|jS)N)r7)rr*rrr_get_call_helpermszBaseCallConv._get_call_helperc Cs|j}||jN|||j}t|t ||| |WdQRX| |WdQRX||j | d| |WdQRX||j| |WdQRX|dd| |||dS)zT Given a non-ok *status*, raise the corresponding Python exception. NZPyExc_StopIterationZPyExc_SystemErrorz*unknown error when calling native function)functionZappend_basic_blockr"rZ err_clearZ unserializerrZ if_likelyZ is_not_nullZ raise_objectbranchrZ err_set_nonerZerr_set_stringZposition_at_end)rr*ZapistatusZbbendexcrrr raise_errorps"    zBaseCallConv.raise_errorcCs ||}||}|||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_packerZfrom_arguments)rr*argtypesfuncZraw_argsarginforrrdecode_argumentss  zBaseCallConv.decode_argumentscCs |j|S)zF Get an argument packer for the given argument types. )rZget_arg_packer)rrArrrr@szBaseCallConv._get_arg_packerN)__name__ __module__ __qualname__rr-r!r1r3r4r8r9r>rDr@rrrrr3s rc@sdeZdZdZddZddZdddZd d Zd d Zd dZ ddZ dddZ ddZ ddZ dS)MinimalCallConva 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). cCstS)N)_MinimalCallHelper)rr*rrrr6sz!MinimalCallConv._make_call_helpercCsP|jjd}|j|jjks4tt|jt|jjf|||||tdS)Nr) r:argsr#pointeeAssertionErrorstrstorer. RETCODE_OK)rr*r,retptrrrrr%s   zMinimalCallConv.return_valueNc Cs|dk r t|ts td|f|dk r@t|ts@td|f|dk rx|}|dkr\|}||j|jf}d|kr|d}nd}||}| |||} | |t | dS)Nz-exc should be None or exception class, got %rz(exc_args should be None or tuple, got %r) issubclass BaseException TypeErrorr&tuple_raw_function_namefilenameliner9_add_exceptionr.r) rr*r=exc_argsloc func_namefnamelocinfoZ call_helperexc_idrrrreturn_user_excs"   zMinimalCallConv.return_user_exccCs|||jdS)N)r.r )rr*r<rrrreturn_status_propagatesz'MinimalCallConv.return_status_propagatecCs t|trt|}||dS)N)r&intrret)rr*r rrrr.s z#MinimalCallConv._return_errcode_rawc Csx|d|t}|d|t}|||}||}|d|t}|d|t}|d|t} t|||||| |dd} | S)z? Given a return *code*, get a Status instance. z==z>=N)r r r rr rrr) icmp_signedrOr/or_not_r0r2RETCODE_USEREXCr ) rr*r normr okerrr=rrr<rrr_get_return_statuss   z"MinimalCallConv._get_return_statuscCs4||}t|j}||}tt|g|}|S)zQ Get the implemented Function type for *restype* and *argtypes*. )r@listargument_typesr4r FunctionTyper)rr5rArCresptrfntyrrrget_function_types    z!MinimalCallConv.get_function_typeFcCs>|rt||}|||dd|Dd|jd_|S)zA Set names and attributes of function arguments. cSsg|] }d|qS)zarg.r).0arrr sz5MinimalCallConv.decorate_function..z.retr)rLr@ assign_namesr?rJname)rfnrJ fe_argtypesnoaliasrCrrrdecorate_functions    z!MinimalCallConv.decorate_functioncCs|jddS)z@ Get the Python-level arguments of LLVM *func*. rN)rJ)rrBrrrr?szMinimalCallConv.get_argumentscCs|jdjj}t||}|t||||}|||}|gt |} | || } | || } | |} |j ||| } | | fS)z3 Call the Numba-compiled *callee*. r)rJr#rKr alloca_oncerNget_null_valuer@ as_argumentsrkcallrjloadrget_returned_value)rr*calleerestyargtysrJr+ retvaltmprCrealargsr r<r,outrrr call_function s      zMinimalCallConv.call_function)NNN)F)rErFrG__doc__r6r%r_r`r.rjrpryr?rrrrrrHs   rHc@s(eZdZdZddZddZddZdS) rIz 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. cCs i|_dS)N) exceptions)rrrrr#sz_MinimalCallHelper.__init__cCs"t|jt}|||f|j|<|S)z Parameters ---------- exc : exception type exc_args : None or tuple exception args locinfo : tuple location information )lenr FIRST_USEREXC)rr=rYr]r^rrrrX&s z!_MinimalCallHelper._add_exceptioncCs2y |j|Stk r,d|}t|ffSXdS)Nz#unknown error %d in native function)rKeyError SystemError)rr^msgrrr get_exception5s  z _MinimalCallHelper.get_exceptionN)rErFrGrrrXrrrrrrIsrIc@s~eZdZdZedZddZddZddd Z d d Z d d Z ddZ ddZ dddZddZddZddZddZdS) CPUCallConva 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). rcCsdS)Nr)rr*rrrr6RszCPUCallConv._make_call_helpercCsP||j}|j|jjks4tt|jt|jjf|||||tdS)N) _get_return_argumentr:r#rKrLrMrNr.rO)rr*r,rPrrrr%Us   zCPUCallConv.return_valueNc Cs|dk r t|ts td|f|dk r@t|ts@td|f|dkrNt}|j|}|dk r|}|dkrv|}||j|j f}d|krd}nd}|||f}| |} | |j } | | | ||tdS)Nz-exc should be None or exception class, got %rz(exc_args should be None or tuple, got %r)rQrRrSr&rTrZget_python_apirUrVrWZserialize_object_get_excinfo_argumentr:rNr.rf) rr*r=rYrZr[Zpyapir\r]Z struct_gvexcptrrrrr_\s,       zCPUCallConv.return_user_exccCs,||j}||j||||jdS)N)rr:rNrr.r )rr*r<rrrrr`}s z#CPUCallConv.return_status_propagatecCs||dS)N)rb)rr*r rrrr.szCPUCallConv._return_errcode_rawc Cs|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. z==z>=)r r r rr rrr)rcrOr/r0r2rdrerfZselectrr excinfo_ptr_tZ Undefinedr ) rr*r rrgr r=rrhrirr<rrrrjs$  zCPUCallConv._get_return_statuscCs<||}t|j}||}tt|ttg|}|S)zQ Get the implemented Function type for *restype* and *argtypes*. ) r@rkrlr4rrmr PointerTyper)rr5rArCrnrorrrrps    zCPUCallConv.get_function_typeFc Cs||}|||dd|D||}d|_|d|d||}d|_|d|d|r||}x.|D]&}t|jt j r|d|dqW|S)zU Set names of function arguments, and add useful attributes to them. cSsg|] }d|qS)zarg.r)rqrrrrrrssz1CPUCallConv.decorate_function..rPZ nocapturerxexcinfo) r@rtr?rruZ add_attributerr&r#rr) rrvrJrwrxrCZretargZexcargrrrrrrys$           zCPUCallConv.decorate_functioncCs|jddS)z@ Get the Python-level arguments of LLVM *func*. N)rJ)rrBrrrr?szCPUCallConv.get_argumentscCs |jdS)Nr)rJ)rrBrrrrsz CPUCallConv._get_return_argumentcCs |jdS)Nr)rJ)rrBrrrrsz!CPUCallConv._get_excinfo_argumentcCs||jj}t||}|t||tj|tt dd}| |} t | ||}||g|} | || } ||| ||} ||} |j||| }| |fS)z3 Call the Numba-compiled *callee*. r)ru)rZ function_typerKrrzrNr{rr excinfo_tr@rkr|r}rjr~rr)rr*rrrrJr+rrrCrr r<r,rrrrrs      zCPUCallConv.call_function)NNN)F)rErFrGr itertoolscountZ _status_idsr6r%r_r`r.rjrpryr?rrrrrrrrAs   rc@seZdZddZdddZdS) ErrorModelcCs ||_dS)N) call_conv)rrrrrrszErrorModel.__init__NcCs$|jr|j|t||dSdSdS)NTF)raise_on_fp_zero_divisionrr_ZeroDivisionError)rr*rYrZrrrfp_zero_divisions  zErrorModel.fp_zero_division)NN)rErFrGrrrrrrrsrc@seZdZdZdZdS)PythonErrorModelzL The Python error model. Any invalid FP input raises an exception. TN)rErFrGrrrrrrrsrc@seZdZdZdZdS)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 FN)rErFrGrrrrrrrs r)ZpythonZnumpycCst||jS)zF Create an error model instance for the given target context. ) error_modelsr)Z model_namerrrrcreate_error_modelsr)%r collectionsrrZllvmliterZnumbarrbaserrr ZIntTypeZint32_trrrOr0r/r2rrfobjectrrHrIZLiteralStructTyperrrrrrrrrrrrrs:   k~! '