
    qi6                     v   d dl Z d dlmZ d dlmZ d dlmZ d dlm	Z	 d dl
mZ d dlmZmZmZmZmZmZmZmZmZ d dlmZmZ d dlmZ d d	lmZ d dlZd d
lmZm Z m!Z! d dl"m#Z#  G d dejH                        Z% G d dejH                        Z& G d de      Z' eddddddddddddddd d!d"      Z( G d# d$e(e      Z)y)%    N)ir)_dynfunc)PyCallWrapper)BaseContext)	utilstypesconfigcgutilscallconvcodegen	externalsfastmathpass
intrinsics)TargetOptionsinclude_default_options)rtsys)global_compiler_lock)ParallelOptionsFastMathOptionsInlineOptions)ufunc_dbc                   *    e Zd Zdej                  fgZy)ClosureBodyenvN__name__
__module____qualname__r   pyobject_fields     @/opt/pipecat/venv/lib/python3.12/site-packages/numba/core/cpu.pyr   r      s    u~~&'Gr"   r   c                   D    e Zd Zdej                  fdej                  fgZy)EnvBodyglobalsconstsNr   r!   r"   r#   r%   r%      s!    	ENN#	5>>"Gr"   r%   c                        e Zd ZdZdZd fd	Zd Zed        ZddZ	d Z
ed        Zd	 Zd
 Zed        Zd ZddZd Zd Zd Zd Zd Z	 ddZd Zd Zd Zd Z xZS )
CPUContextz0
    Changes BaseContext calling convention
    Tc                 &    t         |   ||       y N)super__init__)self	typingctxtarget	__class__s      r#   r-   zCPUContext.__init__)   s    F+r"   c                 8    | j                   j                  |      S r+   )_internal_codegen_create_empty_module)r.   names     r#   create_modulezCPUContext.create_module-   s    %%::4@@r"   c                     t         j                  dk(  | _        t        j                  d      | _        t        j                         dk(  rt        j                  d       t        j                  j                  |        y )N    z
numba.execs390xzlibgcc_s.so.1)r   MACHINE_BITSis32bitr   JITCPUCodegenr3   platformmachinellload_library_permanentlyr   c_math_functionsinstallr.   s    r#   initzCPUContext.init0   s^    **b0!(!6!6|!D (''8 	""**40r"   c                 4   | j                   dk(  rt        j                         dk(  rd }t        |j                        D ]r  \  }}t        |j                  t        j                        s+|j                  j                  dk  sEd}|r|t        |      k  r||   }|j                   ||             t |j                  j                  }t        |t        j                        r2|j                  dk  r"|j                  j                   ||             yyyyy)aw  
        Implementation of caller Type Promotions for s390x ABI requirement.
        See https://github.com/numba/numba/issues/9640

        On s390x, the ABI requires that any integer argument or return
        value smaller than 64 bits must be promoted to 64 bits by the caller.
        The callee can then safely assume the high-order bits of the register
        are correctly filled (sign-extended or zero-extended).
        Without these attributes, LLVM may leave garbage in the high bits,
        leading to undefined behavior (e.g., segfaults) when the callee
        performs 64-bit operations on 32-bit values.
        @   r9   c                 X    t        | t        j                        r| j                  rdS dS y)z
                Map Numba types to LLVM extension attributes.
                Signed integers -> signext (sign extension)
                Unsigned/Booleans -> zeroext (zero extension)
                signextzeroext)
isinstancer   Integersigned)numba_tys    r#   get_ext_attrz8CPUContext.apply_target_attributes.<locals>.get_ext_attrJ   s&     h6(09FYF r"   N)address_sizer=   r>   	enumerateargsrJ   typer   IntTypewidthlenadd_attributereturn_value)	r.   	llvm_funcargtypesrestyperN   iargn_tyrettys	            r#   apply_target_attributesz"CPUContext.apply_target_attributes<   s     "x'7'7'9W'D! $INN3 :3chh

38KDAH$5'{%%l4&89: **//E%,r1A&&44\'5JK 2B,+ (E"r"   c                    t        j                  |        ddlm}m}m}m}m}m}m	}m
}m}	m}
m}m}m} ddlm}m} ddlm}m} ddlm}m}m} ddlm}m} ddlm}m} ddl m!}m"} dd	l m#}m$} dd
l%m&}m'} ddlm(} ddlm)}  ddlm*}!m+}"m,}#m-}$ ddlm.}% ddl/m0}& | jc                  |!jd                         | jc                  |%jd                         | jc                  |"jd                         | jc                  | jd                         | jc                  |#jd                         | jc                  |$jd                         | jc                  |&jf                         th        jj                  jl                  jo                          ddl8m9}' y )Nr   )builtinscharseqenumimplhashingheapq	iteratorslistobjnumbersrangeobjsetobjslicingtupleobjunicode)optionalinline_closurecall)gdb_hookliteral)linalg	arraymatharrayobj)generator_coregenerator_methods)polynomial_corepolynomial_functions)	typeddictdictimpl)	typedlist
listobject)jitclassfunction_type)
npdatetime)npyimpl)	cmathimplmathimpl	printimpl
randomimpl)cffiimpl)ClassBuilder)ndarray):r   
initializenumba.cpythonra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   rl   rm   
numba.corern   ro   
numba.miscrp   rq   numba.nprr   rs   rt   numba.np.randomru   rv   numba.np.polynomialrw   rx   numba.typedry   rz   r{   r|   numba.experimentalr}   r~   r   r   r   r   r   r   r    numba.experimental.jitclass.baser   install_registryregistryclass_impl_registrynumbacoreentrypointsinit_allnumba.np.unsafer   )(r.   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   rl   rm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r   r   r   r   r   r   jitclassimplr   s(                                           r#   load_additional_registriesz%CPUContext.load_additional_registriesa   s    		- 	- 	- 	-
 	<088EM35>' 	%LL'	i001h//0h//0g../i001j112l>>? 	

'') 	,r"   c                 .    | j                   j                  S r+   )r3   target_datarC   s    r#   r   zCPUContext.target_data   s    %%111r"   c                 T    t        j                  |fi |}| j                  |d      S )NT)r3   aot_mode)r   AOTCPUCodegen	subtarget)r.   r5   aot_optionsaot_codegens       r#   with_aot_codegenzCPUContext.with_aot_codegen   s2    ++D@K@~~'+  - 	-r"   c                     | j                   S r+   )r3   rC   s    r#   r   zCPUContext.codegen   s    %%%r"   c                 ,    t        j                  |       S r+   )r   CPUCallConvrC   s    r#   	call_convzCPUContext.call_conv   s    ##D))r"   c                 p    t        j                  ||t        j                  d         }t	        | ||d      S )z
        From the given *envptr* (a pointer to a _dynfunc.Environment object),
        get a EnvBody allowing structured access to environment fields.
        offsetof_env_bodyT)refcast_ref)r
   pointer_addr   
_impl_infor%   )r.   builderenvptrbody_ptrs       r#   get_env_bodyzCPUContext.get_env_body   s9    
 &&VX001DEGtW(TBBr"   c                 ^   | j                  |j                  | j                  | j                              }|j	                  |      }| j                  |      }|j                  ||| j                  j                         | j                  ||      }|j                  | j                  ||      S )N)return_pyobject	debug_msg)declare_env_globalmoduleget_env_namefndescloadget_python_apiemit_environment_sentryenv_namer   get_env_managerenvironment)r.   r   r   envgvenvargpyapienv_bodys          r#   r   zCPUContext.get_env_manager   s    ''(,(9(9$++(FHe$##G,%%+kk** 	& 	

 $$Wf5$$T%5%5xHHr"   c                 V    t        j                  ||t        j                  d   |      S )z~
        From the given *genptr* (a pointer to a _dynfunc.Generator object),
        get a pointer to its state area.
        offsetof_generator_state)return_type)r
   r   r   r   )r.   r   genptrr   s       r#   get_generator_statezCPUContext.get_generator_state   s-    
 ""VX001KL#% 	%r"   c                 6    ddl m} |j                  | |||      S )zR
        Build a list from the Numba *list_type* and its initial *items*.
        r   )rg   )r   rg   
build_list)r.   r   	list_typeitemsrg   s        r#   r   zCPUContext.build_list   s     	*!!$EBBr"   c                 6    ddl m} |j                  | |||      S )zP
        Build a set from the Numba *set_type* and its initial *items*.
        r   )rj   )r   rj   	build_set)r.   r   set_typer   rj   s        r#   r   zCPUContext.build_set   s     	)gx??r"   c                 8    ddl m} |j                  | ||||      S )Nr   )
dictobject)r   r   	build_map)r.   r   	dict_type
item_typesr   r   s         r#   r   zCPUContext.build_map   s    *##D'9j%PPr"   c                     | j                   r t        j                  || j                          | j                  rt	        j
                  |       |j                  t        j                         y r+   )	fastmathr   rewrite_moduler;   r   
fix_divmodadd_linking_libraryr   library)r.   modr   s      r#   post_loweringzCPUContext.post_lowering   sF    ==''T]];<< !!#&##EMM2r"   c           	      .   | j                  d      }| j                  j                  |j                  |j                        }t        j                  |||j                        }t        | ||||||      }	|	j                          |j                  |       y )Nwrapper)call_helperrelease_gil)r6   r   get_function_typerZ   rY   r   Functionllvm_func_namer   buildadd_ir_module)
r.   r   r   r   r   r   wrapper_modulefntywrapper_calleer   s
             r#   create_cpython_wrapperz!CPUContext.create_cpython_wrapper   s~    ++I6~~//P^T%+%:%:<nn &,79 	n-r"   c                    | j                  d      }| j                  j                  |j                  |j                        }t        j                  |||j                        }|j                  D cg c]  }| j                  |       }	}| j                  |j                        }
t        j                  |
|	      }t        j                  |||j                        }t        j                  |j                  d            }| j                  j                  |||j                  |j                  |j                  d      \  }}|j                  |j                   d      5  | j#                  |      }|j%                         }| j                  j'                  |||       | j)                  |j*                  t-        |             }|j/                  |      }|j1                  |       |j3                  |       |j5                  |       d d d        |j7                  |       |j9                  |       y c c}w # 1 sw Y   1xY w)Ncfunc_wrapperentry)noinline)attrsF)likely)r6   r   r   rZ   rY   r   r   r   get_value_typeFunctionTypellvm_cfunc_wrapper_name	IRBuilderappend_basic_blockcall_functionrQ   if_thenis_errorr   
gil_ensureraise_errorinsert_const_stringr   reprstring_from_stringerr_write_unraisabledecrefgil_releaseretr   )r.   r   r   r   r   r   r   r   tyll_argtypesll_return_typewraptywrapfnr   statusoutr   	gil_statecstrstrobjs                       r#   create_cfunc_wrapperzCPUContext.create_cfunc_wrapper   s   ++O<~~//P^T%+%:%:< :@I2t**2.II,,V^^<=^V#;;=,,v88ABnn22^V^^V__KK} 3 . __V__U_; 
	) ''0E((*INN&&wv>++GNNDJGD--d3F&&v.LL i(
	) 	Cn-1 J
	) 
	)s   1H3 B(H88Ic                 :   |j                  |j                        }d|j                  }t        j                  |j                         |j                  j                  d      d   ||||f      }|j                  j                  | j                  |      |       |S )z
        Returns
        -------
        (cfunc, fnptr)

        - cfunc
            callable function (Can be None)
        - fnptr
            callable function address
        - env
            an execution environment (from _dynfunc)
        zcompiled wrapper for .)
get_pointer_to_functionllvm_cpython_wrapper_namequalnamer   make_functionlookup_modulesplitr   set_envr   )r.   r   r   r   fnptrdoccfuncs          r#   get_executablezCPUContext.get_executable  s     //,,.
 ,2??<&&v';';'='-'<'<S'A"'E'*E3(/z	) 	 1 1& 93?r"   c                     t        j                  t         j                  |d      }| j                  | j	                  |            S )zI
        Calculate the size of an array struct on the CPU target
        A)r   Arrayint32get_abi_sizeofr   )r.   ndimarytys      r#   calc_array_sizeofzCPUContext.calc_array_sizeof#  s6     EKKs3""4#6#6u#=>>r"   c                 ,    t        j                  |      S r+   )r   get_ufunc_info)r.   	ufunc_keys     r#   r#  zCPUContext.get_ufunc_info+  s    &&y11r"   )cpu)NN)F)r   r   r   __doc__allow_dynamic_globalsr-   r6   r   rD   r_   r   propertyr   r   r   r   r   r   r   r   r   r   r   r   r  r  r!  r#  __classcell__)r1   s   @r#   r)   r)   #   s     !,A 	1 	1#LJ*,X 2 2-
& * *CI%C@Q
	3 ,1
..@:?2r"   r)   nopythonforceobjlooplift_nrtdebugboundschecknogilno_rewritesno_cpython_wrapperno_cfunc_wrapperparallelr   error_modelinlineforceinline_dbg_extend_lifetimes_dbg_optnonec                       e Zd Zd Zy)CPUTargetOptionsc                 .   |j                  d      sd|_        |j                  d      sd|_        |j                  dd       |j                  d      st        j
                  |_        |j                  d      s)|j                  rd|_        nt        j                  |_        |j                  d      s|j                  |_	        d|_
        |j                  d	       |j                  d
d       |j                  d       |j                  rd|_        y y )Nenable_pyobjectTenable_loopliftnrt)default	debuginfodbg_extend_lifetimesr/  r   r5  pythonr7  F)is_setr=  r>  inherit_if_not_setr	   DEBUGINFO_DEFAULTrA  rB  EXTEND_VARIABLE_LIFETIMESr/  enable_pyobject_loopliftr7  dbg_optnone)r.   flagsoptionss      r#   finalizezCPUTargetOptions.finalizeH  s    ||-.$(E!||-.$(E!   5||K($66EO||23 .2* .4-M-M*||M* %E)-&  ,   A  / %E r"   N)r   r   r   rL  r!   r"   r#   r;  r;  G  s    "&r"   r;  )*r=   llvmlite.bindingbindingr?   llvmliter   r   r   numba.core.callwrapperr   numba.core.baser   r   r   r   r	   r
   r   r   r   r   r   numba.core.optionsr   r   numba.core.runtimer   numba.core.compiler_lockr   numba.core.entrypointsnumba.core.cpu_optionsr   r   r   r   r   	Structurer   r%   r)   _options_mixinr;  r!   r"   r#   <module>rY     s        0 '= = = E $ 9 D D 
('## (g I2 I2^ )
#*#&~} #&r"   