J/PhʱddlmZddlZddlZddlmZmZddlmZddl m Z ddl m Z ddlmZddlmZddlmZmZmZmZmZmZmZmZdd lmZmZmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-e j.e j/dZ0e0Z1e0Z2Gdde3Z4ej5dZ6Gdde3Z7Gdde3Z8dZ9Gdde3Z:ej5dZ;e;dS)) defaultdictN) permutations takewhile)contextmanager)cached_property)ir)Constant)typesutils datamodel debuginfofuncdescconfigcgutilsimputils)eventerrors targetconfig)_dynfunc _helperlib)global_compiler_lock PythonAPI) user_functionuser_generatorbuiltin_registryimpl_ret_borrowedRegistryLoader)builtinscHeZdZdZdZdZdZdZdZdZ dZ d Z d Z d S) OverloadSelectora  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 c"g|_i|_dSN)versions_cacheselfs O/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/core/base.py__init__zOverloadSelector.__init__%s  c||j|}|||}||j|<|Sr$)r&get_find)r(sigouts r)findzOverloadSelector.find*s:kooc"" ;**S//C"DK  r+c||}|r|||Stj|d|)Nz, )_select_compatible_best_signaturerNumbaNotImplementedError)r(r/ candidatess r)r.zOverloadSelector._find1sV,,S11  Dd22:>>? ?1T2B2BS2B2BCC Cr+cZi}|jD] \}}|||r|||<!|S)zL Select all compatible signatures and their implementation. )r%_match_arglist)r(r/r0ver_sigimpls r)r3z#OverloadSelector._select_compatible8sE!] $ $MGT""7C00 $#G  r+c||\}t|dkr|dttfd|}t|dkrpdt|g}|D]"}|d|||gz }#t jd||dS)zB Returns the best signature out of the candidates rc|kSr$)x firstscore genericitys r)z2OverloadSelector._best_signature..JsJqMZ,Gr+z{n} ambiguous signatures)nz {0} => {1} )_sort_signatureslenlistrformatrNumbaTypeErrorjoin)r(r6orderedsamemsgr/r@rAs @@r)r4z OverloadSelector._best_signatureBs#33J?? w<)r?rAs r)rBz3OverloadSelector._sort_signatures..ds *Q-r+)key)rintrkeysr8sorted)r(r6thisothermatchedrKrAs @r)rEz!OverloadSelector._sort_signaturesSs!%% ' (9(9Q??? & &KD%))d)NNG &4   A%   **0G0G0G0GHHH ""r+ch|r^t|dtjr>t|t|z dz}|dd|djf|zz}t|t|krdSt ||D]\}}|||sdSdS)z 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. r<NFT) isinstancer VarArgrFdtypezip_match)r(rQrRndiffformalactuals r)r8zOverloadSelector._match_arglistgs  N:k"ou|DD N $$s;'7'77!;E%crc*k"o.C-E-MMK {  s;// / /5!+{;;  NFF;;vv.. uu tr+c||krdStj|krdSt|trSt |tjr;t|trt ||rdSt||rdSdSdSdS)NT)r Anyr]type issubclassType)r(rcrds r)razOverloadSelector._match{s V  4 Y& 4  % % *VUZ*H*H &$'' Jvv,F,F tFF++ t       r+ct|ts J||f|j||f|jdS)zB Add a formal signature and its associated value. N)r]tupler%appendr&clear)r(valuer/s r)rlzOverloadSelector.appendsZ#u%%33s|333 c5\*** r+N) __name__ __module__ __qualname____doc__r*r1r.r3r4rEr8rarlr>r+r)r"r"s DDD"###((   r+r"ctjdtdtjt jfD]6}|D]\}}d|z}tj|| 7tjj D]V}t|tr?t|tr*tjd|jzt|WdS)zM Execute once to install special symbols into the LLVM symbol table. _Py_NoneStructNnumba_zPyExc_%s)ll add_symbolidr c_helpersritemsr r__dict__valuesr]rgrh BaseExceptionro)rypy_name c_addressc_nameobjs r)_load_global_helpersrs M"BtHH---!*H,>?-- "+//"3"3 - - GY'F M&) , , , , - ~&--//@@ c4  @Z]%C%C @ M* 5r#ww ? ? ?@@r+cDeZdZdZdZdZdZdZej Z e dZ e j dZ dZ dZdZdZdZdZdZdZdZdZdZd Zd dd d Zd ZdZdZdZe dZedZ edZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(didZ)didZ*dZ+dZ,dZ-d Z.d!Z/djd"Z0d#Z1d$Z2d%Z3d&Z4d'Z5djd(Z6djd)Z7d*Z8d+Z9d,Z:d-Z;dkd/Zd2Z?d3Z@d4ZAd5ZBd6ZCd7ZDd8ZEd9ZFd:ZGd;ZHd<ZId=ZJd>ZKd?ZLd@ZMdAZNdldBZOdCZPdDZQdjdEZRdFZSdGZTdHZUdIZVdJZWdKZXidfdLZYidd.fdMZZifdNZ[dOZ\dPZ]dQZ^dRZ_dSZ`dTZadmdVZbdndWZcdodXZddjdYZedZZfd[Zgdjd\Zhd]Zid^Zjd_Zkd`ZldaZmdbZndcZoddZpe deZqerdfZsdgZtdhZudS)p BaseContexta  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. Fc@tj tjS|jSr$)r BOUNDSCHECK _boundscheckr's r)enable_boundscheckzBaseContext.enable_boundschecks   )% %  r+c||_dSr$)r)r(rns r)rzBaseContext.enable_boundschecks!r+Ncttj|_||_ddlm}||_|||_i|_ tt|_ tt|_ tt|_t|_t|_i|_i|_i|_d|_g|_d|_t.j|_|dS)Nr)target_registryF)rr MACHINE_BITS address_sizetyping_contextnumba.core.target_extensionr target_nametarget _registriesrr"_defns _getattrs _setattrs_casts_get_constants _generators special_opscached_internal_func_pid_codelib_stackrr default_managerdata_model_managerinit)r(rrrs r)r*zBaseContext.__init__s!.,??????!%f- !"233 $%566$%566&(( .00$&!  !"+"; r+cdS)z3 For subclasses to add initializer Nr>r's r)rzBaseContext.initr+c||t|jdS)zy Refresh context with new declarations from known registries. Useful for third-party extensions. N)load_additional_registriesinstall_registryrrrefreshr's r)rzBaseContext.refreshsJ ''))) ./// ##%%%%%r+cdS)zT Load target-specific registries. Can be overridden by subclasses. Nr>r's r)rz&BaseContext.load_additional_registriesrr+r>abi_tagsuidc2tj||||S)z( Perform name mangling. r)rdefault_mangler)r(namer rrs r)manglerzBaseContext.manglers'ehCPPPPr+c|jS)zGet 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. )env_name)r(fndescs r) get_env_namezBaseContext.get_env_name"s r+c||jvrKtj|tj|}d|_tj|jj|_ |j|S)aDeclare 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. )rcommon) globalsllvmirGlobalVariabler voidptr_tlinkageget_null_valuergpointee initializer)r(moduleenvnamegvs r)declare_env_globalzBaseContext.declare_env_global*sU &. ( (&vw/@wOOOB!BJ$3BGODDBN~g&&r+c6tj|j|Sr$)r ArgPackerr)r(fe_argss r)get_arg_packerzBaseContext.get_arg_packer?s"4#:GDDDr+c6tj|j|Sr$)r DataPackerr)r(fe_typess r)get_data_packerzBaseContext.get_data_packerBs#D$;XFFFr+ctr$NotImplementedErrorr's r) target_datazBaseContext.target_dataEs!!r+ctS)zN All module attrs are constant for targets using BaseContext. )rkr's r)nonconst_module_attrsz!BaseContext.nonconst_module_attrsIs wwr+c0ddlm}|||jS)Nr) NRTContext)numba.core.runtime.contextr enable_nrt)r(rs r)nrtzBaseContext.nrtPs(999999z$000r+c Ftj|}|D]H\}}t||s"td|t |||I||uri|_|S)Nzunknown option {0!r})copyrzhasattr NameErrorrHsetattrcodegenr)r(kwsrkvs r) subtargetzBaseContext.subtargetUsiooIIKK  DAq3?? B 6 = =a @ @AAA CA     ;;==  . .')C $ r+c |j|}n)#t$rt|}||j|<YnwxYw||d||d||d||d||ddS)zx Install a *registry* (a imputils.Registry instance) of function and attribute implementations. functionsgetattrssetattrscasts constantsN) rKeyErrorrinsert_func_defnnew_registrations_insert_getattr_defn_insert_setattr_defn_insert_cast_defn_insert_get_constant_defn)r(registryloaders r)rzBaseContext.install_registry`s  0%h/FF 0 0 0#H--F)/D X & & & 0 f66{CCDDD !!&":"::"F"FGGG !!&":"::"F"FGGG v77@@AAA &&v'?'? 'L'LMMMMMs #66cZ|D]'\}}}|j|||(dSr$)rrl)r(defnsr:funcr/s r)rzBaseContext.insert_func_defnpsA$ 0 0OD$ K  $ $T3 / / / / 0 0r+cZ|D]'\}}}|j|||(dSr$)rrlr(rr:attrr/s r)rz BaseContext._insert_getattr_defntA$ 3 3OD$ N4 ' 'c 2 2 2 2 3 3r+cZ|D]'\}}}|j|||(dSr$)rrlrs r)rz BaseContext._insert_setattr_defnxrr+cL|D] \}}|j||!dSr$)rrlr(rr:r/s r)rzBaseContext._insert_cast_defn|s: * *ID# K  tS ) ) ) ) * *r+cL|D] \}}|j||!dSr$)rrlrs r)rz%BaseContext._insert_get_constant_defns; 2 2ID#   & &tS 1 1 1 1 2 2r+crt||}|j|||jdSr$)rrrl signature)r(rrlibsr:s r)insert_user_functionz BaseContext.insert_user_functions6VT** D  t~66666r+cvt|tjsJt||}||f|j|<dSr$)r]r Generatorrr)r(gentygendescrr:s r)insert_generatorzBaseContext.insert_generators@%11111gt,,")4-r+c|j|=dS)zl Remove user function *func*. KeyError is raised if the function isn't known to us. N)r)r(rs r)remove_user_functionz BaseContext.remove_user_functions K   r+cfd|jD}|j}tj||}|S)Nc:g|]}|Sr>)get_argument_type).0atyr(s r) z:BaseContext.get_external_function_type..s7000**3//000r+)argtypesrrestyper FunctionType)r(rrr fntys` r)get_external_function_typez&BaseContext.get_external_function_types[0000%000((88"7H55 r+c|j|j|j}t j|||j}|j||j|j|j |j rN|j d|j d|j d|S)N)noalias alwaysinlinenoinlineoptnone) call_convget_function_typer rrget_or_insert_function mangled_namedecorate_functionargsrinline attributesadddiscard)r(rrr fns r)declare_functionzBaseContext.declare_functions~//PP  +FD&:M N N ((V[&/SYSa(bbb = - M  n - - - M ! !* - - - M ! !) , , , r+c||}tj|||j}|jsJt |j|jD]\}}d|z|_|S)Nzarg.%s)r rrris_declarationr`rr)r(rrr rakavs r)declare_external_functionz%BaseContext.declare_external_functionsn..v66  +FD&:M N N    &+rw// $ $FBmBGG r+ct}d|z}tj|ddz}||||}t j||S)zL Insert constant *string* (a str object) into module *mod*. z .const.%szutf-8)GENERIC_POINTERrmake_bytearrayencodeinsert_unique_constr bitcast)r(modstring stringtypertextrs r)insert_const_stringzBaseContext.insert_const_strings^% V#%fmmG&<&>>r+c@|j|Sr$)rget_return_typer8s r)r;zBaseContext.get_return_types&r*::<<zBaseContext.get_data_types&r*88:::r+c@|j|Sr$)rget_value_typer8s r)r@zBaseContext.get_value_types&r*99;;;r+cx|j|||}||||dS)z 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). )alignN)ras_datastore)r(builderr9rnptrrBdatavals r) pack_valuezBaseContext.pack_values? )"-55guEE gs% 00000r+cJ|j|}||||S)z 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). )rload_from_data_pointer)r(rEr9rFrBdms r) unpack_valuezBaseContext.unpack_values)  $R (((#u===r+c |j|f}|||||S#t$rtd|dwxYw)zU Return a LLVM constant representing value *val* of Numba type *ty*. zCannot lower constant of type '')rr1r)r(rEr9r6r:s r)get_constant_genericz BaseContext.get_constant_genericsm T&++RE22D4gr3// /" T T T%%bbb&RSS S Ts (+A c0|d||S)zx Same as get_constant_generic(), but without specifying *builder*. Works only for simple types. N)rO)r(r9r6s r) get_constantzBaseContext.get_constants ((r3777r+c`||}t|tjSr$)r@r r Undefinedr(r9ltys r)get_constant_undefzBaseContext.get_constant_undefs(!!"%%V-...r+cL||}t|dSr$)r@r rTs r)get_constant_nullzBaseContext.get_constant_null s%!!"%%T"""r+Tch|J|}t|tjr#||}|j|}n|}|j|} t ||j||S#tj $rYnwxYwt|tj r4 | t||S#t$rYnwxYw|r,|| ||dStd||)z Return the implementation of function *fn* for signature *sig*. The return value is a callable with the signature (builder, args). NF) _firstcallNo definition for lowering ) as_functionr]r Callable get_impl_keyr _wrap_implr1rrr5ri get_functionrgrr)r(rr/rZrT overloadss r)r`zBaseContext.get_functionsJ oo b%. ) ) )//#&&C C(IIC C(I innSX66cBB B.    D  b%* % %  ((b3777&      @ LLNNN$$R$?? ?!!ssCC"PQQQs$&(BB! B!?"C"" C/.C/c(|j|dS) r)r)r(rs r)get_generator_desczBaseContext.get_generator_desc0s&q))r+ct|j|d}|t|dd|S)rcr<rr>)radd_linking_libsgetattr)r(rress r)get_generator_implzBaseContext.get_generator_impl5s;u%a( gc6266777 r+cF|||jksJ|Sr$)r@rg)r(rErr9s r)get_bound_functionzBaseContext.get_bound_function<s(""2&&#(2222 r+c||fjv}t|tj}|rY|rWj||ttjrdSt|j|fd}|Sj |} | |fS#tj $rYnwxYwj d} | |fS#tj $rYnwxYwtd|d|)z 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). NcV|}t|||Sr$)rOr) contextrEtypr6rllvalattrtypyvalr(s r)impz$BaseContext.get_getattr..impSs. 55gvuMME,WgvuMMMr+r[.)rr]r Modulerresolve_module_constantsDummyrgpymodrr1rr5r) r(ror const_attr is_modulersrarqrrs ` @@r) get_getattrzBaseContext.get_getattr@sb 4[(BB sEL11   (AA#tLLF~FEK!@!@~t 400NNNNNNN N4(  >>3&)) ).    D N4(  >>3&)) ).    D "!TT"RSSSs$B((B:9B: C!!C32C3ctjdksJjd}jd}fd}j} ||||fS#tj$rYnwxYwjd} ||||fS#tj$rYnwxYwt d|dd|) z Get the setattr() implementation for the given attribute name and signature. The return value is a callable with the signature (builder, args). rOrr<cfd}|S)Nc"||Sr$r>)rErrr:r(r/s r)wrappedz>BaseContext.get_setattr..wrap_setattr..wrappedrstD'3d;;;r+r>)r:rrr(r/s` r) wrap_setattrz-BaseContext.get_setattr..wrap_setattrqs1 < < < < < < < <Nr+Nr[rtz = )rFrrr1rr5r)r(rr/rovaltyrras``` r) get_setattrzBaseContext.get_setattrgs2 38}}!!!!hqk         N4(  < U| < <== =.    D N4(  < U| < <== =.    D "!%(SS$$$#788 8s$ A--A?>A?B00CCcD|j|||S)zG Argument representation to local value representation )r from_argumentr(rEr9r6s r)get_argument_valuezBaseContext.get_argument_values"&r*88#FFFr+cD|j|||S)zK Return value representation to local value representation )r from_returnrs r)get_returned_valuezBaseContext.get_returned_values"&r*66wDDDr+cD|j|||S)zJ Local value representation to return type representation )r as_returnrs r)get_return_valuezBaseContext.get_return_values"&r*44WcBBBr+cD|j|||S)zKPrepare local value representation as argument type representation )r as_argumentrs r)get_value_as_argumentz!BaseContext.get_value_as_arguments"&r*66wDDDr+cD|j|||Sr$)rrCrs r)get_value_as_datazBaseContext.get_value_as_datas &r*227C@@@r+cD|j|||Sr$)r from_datars r)get_data_as_valuezBaseContext.get_data_as_values &r*44WcBBBr+c>||||}|jS)zD Extract the first element of a heterogeneous pair. ) make_helperfirstr(rEr6r9pairs r) pair_firstzBaseContext.pair_firsts#S11zr+c>||||}|jS)zE Extract the second element of a heterogeneous pair. )rsecondrs r) pair_secondzBaseContext.pair_seconds#S11{r+c 0|tjur||S||ks|tjkr|S |j||f}||||||S#t j$rt jd|d|d|wxYw)z 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. z Cannot cast z to z: )r _undef_varrXrfrr1rr5)r(rEr6fromtytotyr:s r)castzBaseContext.casts U% % %))$// / t^^tuy00J B;##VTN33D4gvtS99 9. B B B11.4ffdddCC@BB B Bs *A((-Bc|\}}|\}}|j||} | J||||| } ||||| } |j|} | |j| | fi} || | }|t|dd||| | fS)z 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. Nrr>)r unify_typesrresolve_value_type get_call_typer`rfrg)r(rErTrratbtr!bvr9cavcbvr cmpsigcmpfuncs r)generic_comparezBaseContext.generic_compares BB  , ,R 4 4~~~iiR,,iiR,,"55c::##D$7"b2FF##D&11 ggvr::;;;wwc +++r+c||tj|}tj|_|Sr$)rr Optionalr false_bitvalid _getvalue)r(rEvaltypeoptvals r)make_optional_nonezBaseContext.make_optional_nones=!!'5>'+B+BCC( !!!r+c||tj|}tj|_||_|Sr$)rr rrtrue_bitrdatar)r(rErrnrs r)make_optional_valuezBaseContext.make_optional_valuesD!!'5>'+B+BCC'  !!!r+c|jt}||j|fi}|||}|||fS)zL Return the truth value of a value of the given Numba type. )rrboolrr`)r(rEror6r r/r:s r)is_truezBaseContext.is_trues_"55d;;  !4sfbAA  s++tGcV$$$r+c|jj} |j|}nF#t$r9t j|||}|r|jrtjdkrd|_ YnwxYw|S)z 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). win32 dllimport) functionrrrradd_global_variableaot_modesysplatform storage_class)r(rErorrrrs r) get_c_valuezBaseContext.get_c_values!( /%BB / / /,VS$??B /T] /s|w/F/F#.  / s AAAcpfdt||D}||}|S)NcDg|]\}}||Sr>)r)rr9argrEr(s r)rz6BaseContext.call_external_function..s?222B**7B<<222r+)r`call)r(rEcalleeargtysrretvals`` r)call_external_functionz"BaseContext.call_external_functionsS22222"6400222fd++ r+c@|j|Sr$r=)r(ros r)get_function_pointer_typez%BaseContext.get_function_pointer_types&s+99;;;r+c2||||S)N)cconv)r)r(rEfuncptrrrs r)call_function_pointerz!BaseContext.call_function_pointers||GT|777r+c|j}t}tjtjd|g}t j||d}|||gS)N puts)rr%rr IntTyperrr)r(rEr-r*cstringr rs r) print_stringzBaseContext.print_stringsVn!"6>"#5#5yAA-c4@@||D4&)))r+c|j}||t|}|||dSr$)rr.strr)r(rEr-r*cstrs r) debug_printzBaseContext.debug_print s@n''SYY77 '4(((((r+cD|j}t|tr|||}n|}t jt jdtfd}tj ||d}| ||ft|zS)NrT)var_argprintf) rr]rr.rr rr%rrrrk)r(rE format_stringrr*rr rs r)rzBaseContext.printfsn mS ) ) !++C??DD D"6>"#5#57ISWXXX  +Cx @ @||B%++ 5666r+cRfd|jD}tj|S)zR Get the LLVM struct type for the given Structure class *struct*. c@g|]\}}|Sr>)r@)r_rr(s r)rz/BaseContext.get_struct_type.. s+DDDTQ$%%a((DDDr+)_fieldsrLiteralStructType)r(structfieldss` r)get_struct_typezBaseContext.get_struct_types2EDDDV^DDD'///r+cFt|dSr$)r get_dummy_typer's r)get_dummy_valuezBaseContext.get_dummy_value#s++--t444r+ctSr$)r%r's r)rzBaseContext.get_dummy_type&sr+c 4ddlm}t5|}||j}|`t j} |}| r7| } | dr| j rd|_ d|_ d|_ d|_||j||||j|j||} |j| j| cdddS#1swxYwYdS)z 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. r)compilerNrT)locals) numba.corerrrcreate_libraryror ConfigStackFlagstopis_setr no_compileno_cpython_wrapperno_cfunc_wrappercompile_internalrr return_typeactive_code_libraryadd_linking_librarylibrary) r(rEr:r/rflagsrrrcstk tls_flagscress r)_compile_subroutine_no_cachez(BaseContext._compile_subroutine_no_cache)sj (''''' !  llnnG,,T];;G}#/11 (() $ I ''..)9=)$( #E '+E $%)E ",,T-@$-4-138-0_e4: -<z1BaseContext.compile_subroutine.._s$"M"Mq1?"M"M"M"M"M"Mr+)rr) __code__rg error_model __closure__rkrr-rrrr) r(rEr:r/rrcaching cache_keycachedrs r)compile_subroutinezBaseContext.compile_subroutineOs]Cd.>)?)?@  >FF NU"M"MD44WdC  " "8V 4 4n227B368TCC s{r+c|}|j|j|j}||||}|j|||j|j|\}} tj||j 5|j ||dddn #1swxYwYtj ||||| } | S)aV 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. N) rrrrrinsert_unresolved_refrrrrrrr) r(rErr/rrr rrrhs r)call_unresolvedzBaseContext.call_unresolveds"@,,..~//JJ  * *7D$ ? ?n227B368TCC   &/ : : D D N 2 27F C C C D D D D D D D D D D D D D D D-dGS&#NN sB>>CCctr$r)r(rrenvs r)get_executablezBaseContext.get_executables!!r+c"t||Sr$r)r(rEs r)get_python_apizBaseContext.get_python_apisw'''r+c`|jr||}||}t|tjr|j}|||}||zr.d |||}tj |dSdS)zH Assumes offset starts from a properly aligned location z*{rec}.{attr} of type {type} is not aligned)recrrgN) strict_alignmentoffsettypeofr]r NestedArrayr_get_abi_alignmentr>rHrrI)r(rectyprr)elemtyrBrMs r)sentry_record_alignmentz#BaseContext.sentry_record_alignments  1]]4((F]]4((F&%"344 & **4+=+=f+E+EFFE~ 1BIITJ88+C000 1 1 1 1r+rnc,tj||S)z9 Get a helper class for the given *typ*. )rcreate_struct_proxy)r(rokinds r)get_helper_classzBaseContext.get_helper_classs *3555r+cL|||}|||||S)N)rnref)r3)r(rErornr5r2clss r) _make_helperzBaseContext._make_helpers0##C..s437777r+c6|||||dS)zn Get a helper object to access the *typ*'s members, for the given value or reference. rn)r2r7)r(rErornr5s r)rzBaseContext.make_helpers#   #uc HHHr+c4||||dS)zr As make_helper(), but considers the value as stored in memory, rather than a live value. r)r5r2r9)r(rEror5s r)make_data_helperzBaseContext.make_data_helpers!   #3V DDDr+c8ddlm}||S)Nrarrayobj)numba.npr> make_array)r(ror>s r)r@zBaseContext.make_arrays(%%%%%%""3'''r+c *ddlm}|j|fi|S)z+ Populate array structure. rr=)r?r>populate_array)r(arrkwargsr>s r)rBzBaseContext.populate_arrays1 &%%%%%&x&s55f555r+cxt|tjs J|||||S)zS Get a helper object to access the given complex numbers' members. )r]r Complexr)r(rErorns r) make_complexzBaseContext.make_complexs<#u}--22s222e444r+c||}t|D]\}}||||}|S)zL Create a tuple of the given *typ* containing the *values*. )rV enumerate insert_value)r(rEror|tupir6s r) make_tuplezBaseContext.make_tuplesP%%c**'' 4 4FAs&&sC33CC r+c |j}d}jr|jdvs |j|kr~|jj}||tt|}|t|tt|}n| |j} tj tjdt!| j} tj|d| }||_d}t*j} fd|jD} tj | | } fd |jD}tj | |}||}t*j|jj}||||jj | |||d |S) z Create an array structure reifying the given constant array. A low-level contiguous array constant is created in the LLVM IR. i@BFC)info)orderr z.const.array.dataNcPg|]"}tj|#Sr>rQr intprsr(s r)rz3BaseContext.make_constant_array.."s+III!T&&uz155IIIr+cPg|]"}tj|#Sr>rSrUs r)rz3BaseContext.make_constant_array..&s+LLL1d'' A66LLLr+)rshapestridesitemsizeparentmeminfo)r>r_allow_dynamic_globalslayoutnbytesctypesradd_dynamic_addrrrgrxflattenrcreate_constant_arrayrr bytearrayr5r,rBr@r rTrXrYr@rQrZrBr)r)r(rEroarydatatype size_limitdataptrrrt_addrflatconstsllintp shapevalscshape stridevalscstridescary intp_itemsizes` r)make_constant_arrayzBaseContext.make_constant_arrays %%ci00  & 4''3: +B+BjoG(('DMM@R@R(SSD++GRWW3tCyy>>+RRGG;;SZ;00D26>!3D3DiPTPYFZFZ[[F*74GPPD//99DJG$$UZ00IIIIsyIII .vyAAMLLL LLL 0DD$ts##D'22))%*ci6HII  D!(ty~!F!F"($,%2#*$(  * * *~~r+c|js Jdt|ts Jd|j}|t j}|t j| |}d |}tj |||}d|_ ||_||S)z 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. z#dyn globals disabled in this targetzdyn addr not of int typeznumba.dynamic.globals.{:x}linkonce)r]r]rUrr@r voidptrrQuintpinttoptrrHrrrrload) r(rEintaddrrPr* llvoidptraddrsymnamers r)razBaseContext.add_dynamic_addr7s)PP+PPPP'3''CC)CCCCn'' 66   g66?? JJ.55g>>  (i A A  ||Br+c~t|tjs Jd||jS)z5 Get the ABI size of LLVM type *ty*. Expected LLVM type)r]rri get_abi_sizerr8s r)get_abi_sizeofzBaseContext.get_abi_sizeofLs:"fk**@@,@@@@t/000r+c~t|tjs Jd||jS)z: Get the ABI alignment of LLVM type *ty*. r)r]rrir,rr8s r)r,zBaseContext.get_abi_alignmentSs<"fk**@@,@@@@##D$4555r+cdS)zD Get preferred array alignment for Numba type *ty*. rr>)rnr9s r)get_preferred_array_alignmentz)BaseContext.get_preferred_array_alignmentZs rr+cdS)z?Run target specific post-lowering transformation here. Nr>)r(r*rs r) post_loweringzBaseContext.post_loweringarr+ct)zCreate a LLVM module The default implementation in BaseContext always raises a ``NotImplementedError`` exception. Subclasses should implement this method. r)r(rs r) create_modulezBaseContext.create_modulees "!r+c|jdS)z$Get the active code library r\)rr's r)rzBaseContext.active_code_libraryns"2&&r+c#K|j| dV|jdS#|jwxYw)z5Push the active code library for the context N)rrlpop)r(libs r)push_code_libraryzBaseContext.push_code_librarytsc ""3''' & EEE   # # % % % % %D  # # % % % %s =AcH|j}|D]}||dS)zHAdd iterable of linking libraries to the *active_code_library*. N)rr)r(rcolibrs r)rfzBaseContext.add_linking_libs~s<( + +C  % %c * * * * + +r+c&t|d)aGet 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. z does not support ufuncr)r( ufunc_keys r)get_ufunc_infozBaseContext.get_ufunc_infos""T"B"B"BCCCr+)r>r$)T)F)rn)NNrn)NN)vrorprqrrr(implement_powi_as_math_callimplement_pow_as_math_callenable_debuginfor DIBuilderpropertyrsetterr auto_parallelrr r]fastmath environmentrr*rrrrrrrrrrrrrrrrrrrrrrr rr"r.r2r(rr;r>r@rHrLrOrQrVrXr`rdrirkr{rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r#r%r/r3r7rr;r@rBrGrMrsrarr,rrrrrrrfrr>r+r)rrsC  #(!&#I!!X! """JMHK"HKF>   &&&$   02tQQQQQ '''*EEEGGG""X"_ 11_1   NNN 000333333***22277770000    0000000   ???===;;;<<<1111>>>>TTT888///### R R R RD*** %T%T%TN888>GGG EEE CCC EEE AAACCCBBB$,,,&""" """ %%%  <<<8888***))) 777000555GI+/$$$$L=?d#':ACCCCC      ***X"""(((111$66668888IIIIEEEE(((66655551 1 1 f   *111666   """''X' &&^&+++DDDDDr+rc,eZdZdZdZddZdZdZdS)r_z A wrapper object to call an implementation function with some predefined (context, signature) arguments. The wrapper also forwards attribute queries, which is important. c|t||_||_||_||_dSr$)_wrap_missing_loc _callable_imp_context_sig)r(rsrnr/s r)r*z_wrap_impl.__init__s4*3//NN$$   r+Nc||j||j||}|jt |dd|S)N)locrr>)rrrrfrg)r(rErrrhs r)__call__z_wrap_impl.__call__sHii w 4SiII &&wtVR'@'@AAA r+c,t|j|Sr$)rgr)r(items r) __getattr__z_wrap_impl.__getattr__sty$'''r+c0dt|jzSNz )reprrr's r)__repr__z_wrap_impl.__repr__sT^ 4 444r+r$)rorprqrrr*rrrr>r+r)r_r_s_   (((55555r+r_c<tj|}d|jvS)z.Does function *fn* take ``loc`` argument? r)r pysignature parameters)rr/s r)_has_locrs!  B  C CN ""r+c eZdZdZdZdZdS)rc||_dSr$r)r(rs r)r*z_wrap_missing_loc.__init__s  r+c|jts@fd}d}|D]4} t|}t|||%#t$rY1wxYw|SS)ziWrap function for missing ``loc`` keyword argument. Otherwise, return the original *fn*. c>|d|i|S)Nr)r)rrDrs r)wrapperz+_wrap_missing_loc.__call__..wrappers* 5!!!r4*6***r+)ror)rrrgrAttributeError)r(rattrsrr6rs @r)rz_wrap_missing_loc.__call__sY||  + + + + +'E 0 00!"d++CGT3////&D NIsA AAcd|jzSrrr's r)rz_wrap_missing_loc.__repr__s ))r+N)rorprqr*rrr>r+r)rrsA4*****r+rcRd}d}tj||dS)z)Initial event triggers for LLVM lock c.tjddSNznumba:llvm_lock)r start_eventr>r+r)enter_fnz-_initialize_llvm_lock_event..enter_fns +,,,,,r+c.tjddSr)r end_eventr>r+r)exit_fnz,_initialize_llvm_lock_event..exit_fns )*****r+N)rvffiregister_lock_callback)rrs r)_initialize_llvm_lock_eventrs@---+++F!!(G44444r+)< collectionsrrr itertoolsrr contextlibr functoolsrllvmliterr llvmlite.irr llvmlite.bindingbindingrvrr r r r rrrrrrrnumbarrnumba.core.compiler_lockrnumba.core.pythonapirnumba.core.imputilsrrrrr numba.cpythonr PointerTyperr%PYOBJECTvoid_ptrobjectr"runoncerrr_rrrr>r+r)rs###### --------%%%%%%%%%%%%!!!!!! ^^^^^^^^^^^^^^^^^^^^2222222222&&&&&&&&999999******''''''''''''''#"""""$&$^V^A%6%677  uuuuuvuuup@@@&oDoDoDoDoD&oDoDoDb555555550### * * * * * * * *F 5 5 5r+