1@j,dZddlZddlmZmZddlZddlmZddlm Z m Z m Z m Z ddl ZejdZejdZejdZeje jZeZedZedZedZedZd Zd[d Zd ZiZd\d Zd[dZ Gdde!Z"Gdde"Z#Gdde"Z$Gdde!Z%d]dZ&dZ'd^dZ(dZ)dZ*dZ+d_dZ,d Z-d!Z.d"Z/d#Z0d$Z1d%Z2d&Z3d'Z4ej5d(d)Z6ed`d*Z7edad,Z8ed-Z9edbd/Z:ed0Z;d[d1Z dcd4Z?d[d5Z@ dcd6ZAd7ZBd8ZCd9ZDd:ZEeDZFeCZGd;ZHedZJd?ZKd[d@ZLedddAZMeKZNdBZOdCZPdDZQdEZRdFZSd[dGZTdHZUdIZVdedKZWdLZXdMZYdNZZdOZ[dfdPZ\dfdQZ]dRZ^dSZ_dTZ`dUZadVZbdWZcdXZddYZedZZfdS)gz+ Generic helpers for LLVM code generation. N)contextmanager ExitStack)ir)utilstypesconfig debuginfo cV|d||dS)N!=r) icmp_unsignedtypebuildervalues CC:\Projects\Historical\venv\Lib\site-packages\numba/core/cgutils.py as_bool_bitrs$  uejjmm < <<c|tjd|D}|tj}t|D]\}}||||}|S)zH Create an anonymous struct containing the given LLVM *values*. Ncg|] }|j Sr.0vs r z)make_anonymous_struct..%s+C+C+CqAF+C+C+CrrLiteralStructType Undefined enumerate insert_value)rvalues struct_type struct_valirs rmake_anonymous_structr( st*+C+CF+C+C+CDD R\**J&!!<<1))*a;; rct|}t|}tjtjtjd||S)z0 Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)bufbns rmake_bytearrayr2,s@ #A AA ;r|BJqMM155q 9 99rrc||f}t|}|]ttd|}|jdzt |z}|f}t |}t|||}|t|<|S)zK Returns a specialized StructProxy subclass for the given fe_type. N)rdata_)_fe_type)_struct_proxy_cachegetValueStructProxyDataStructProxy__name__strdictr)fe_typekind cache_keyresbaseclsnamebases clsmemberss rcreate_struct_proxyrF8s$I  ! !) , ,C {)'-#%G 47+++ 7E:..),I& Jrc|i}|}|jjD]7}||t ||}t |||8|D]\}}t ||||S)zJ Copy structure from *src* to *dst* with replacement from *repl*. )copy _datamodel_fieldspopgetattrsetattritems)dstsrcreplkrs r copy_structrSKs | 99;;D ^ # HHQQ ( (Q 1Q Jrc|eZdZdZdZddZdZdZdZdZ dZ d Z d Z fd Z d Zd ZdZdZdZdZxZS) _StructProxyz Creates a `Structure` like interface that is constructed with information from DataModel instance. FE type must have a data model that is a subclass of StructModel. Nc||_|jj|j|_t |jt jjjs'td |j||_ | |j|_ t|j rJ||\}}|jj|j kr1t%d|j d|j|T|j|jjkr$t%d|jjd|j|j ||||_||_dS)NzNot a structure model: {0}zbad ref type: expected z, got zbad value type: expected )_contextdata_model_managerr6rI isinstancenumbacore datamodel StructModel TypeErrorformat_builder _get_be_type_be_type is_pointer _make_refsrpointeeAssertionError as_pointerstore_value _outer_ref)selfcontextrrref outer_refs r__init__z_StructProxy.__init__esk -:4=I$/5:+?+KLL F,33DODDFF F ))$/:: dm,,,,,-- 3 8 t} , , .$(M$<$<$>$>$>$>"JKK K  zY^333$n(1(>(>(> &LMMM M  y 1 1 1 #rcF|t|j|jd}||fS)z Return an (outer ref, value ref) pair. By default, these are the same pointers, but a derived class may override this. NTzfill) alloca_oncer`rb)rkrms rrdz_StructProxy._make_refs~s* ;dmT]$GGGCCxrctNNotImplementedErrorrkr\s rraz_StructProxy._get_be_type!!rctrurvrkindexvals r_cast_member_to_valuez"_StructProxy._cast_member_to_valueryrctrurvr{s r_cast_member_from_valuez$_StructProxy._cast_member_from_valueryrc:t|j|jd|SNr) gep_inboundsr`rirkr|s r_get_ptr_by_indexz_StructProxy._get_ptr_by_indexsDM4;5AAArc`|j|}||Sru)rIget_field_positionr)rkattrnamer|s r_get_ptr_by_namez_StructProxy._get_ptr_by_names+228<<%%e,,,rc|ds ||j|St|z; Load the LLVM value of the named *field*. r5) startswithrIrAttributeErrorrkfields r __getattr__z_StructProxy.__getattr__sC$$ (::5AAB B '' 'rc|dr)tt|||S|||j|<dSz@ Store the LLVM *value* into the named *field*. r5N)rsuperrU __setattr__rIrrkrr __class__s rrz_StructProxy.__setattr__s\   C  Gt,,88FF F:?T_ / / 6 6777rc|j||}|||Sz> Load the LLVM value of the field at *index*. )r`loadrr~)rkr| member_vals r __getitem__z_StructProxy.__getitem__s=]''(>(>u(E(EFF ))%<<.FFF 33DM4947H4D4NPP !D"(e4.3"("5"5 666 E3'''''rc|jjSz. Return the number of fields. )rI field_countrks r__len__z_StructProxy.__len__s**rc|jSzF Return the LLVM pointer to the underlying structure. )rjrs r _getpointerz_StructProxy._getpointers rc@|j|jSzM Load and return the value of the underlying LLVM structure. )r`rrjrs r _getvaluez_StructProxy._getvalues}!!$/222rct|jrJ|j|jksJ|j|jf|j||jdS)z4 Store the value in this structure. N)rcrrbr`rhrirkrs r _setvaluez_StructProxy._setvalues`ej)))))zT]***UZ,G*** E4;/////rNN)r; __module__ __qualname____doc__r6rordrar~rrrrrrrrrrr __classcell__rs@rrUrU\s( H$$$$2"""""""""BBB---(((@@@@@===(((.+++  333 0000000rrUc$eZdZdZdZdZdZdS)r9zl Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). c*|Sru)get_value_typerxs rrazValueStructProxy._get_be_types'')))rc|Srurr{s rr~z&ValueStructProxy._cast_member_to_value rc|Srurr{s rrz(ValueStructProxy._cast_member_from_valuerrNr;rrrrar~rrrrr9r9sK***rr9c$eZdZdZdZdZdZdS)r:zO Create a StructProxy suitable for accessing data persisted in memory. c*|Sru) get_data_typerxs rrazDataStructProxy._get_be_types&&(((rcl|j|}||j|Sru)rI get_model from_datar`rkr|r}models rr~z%DataStructProxy._cast_member_to_values-))%00t}c222rcl|j|}||j|Sru)rIras_datar`rs rrz'DataStructProxy._cast_member_from_values-))%00}}T]C000rNrrrrr:r:sK)))33311111rr:c`eZdZdZddZdZdZdZfdZd Z d Z d Z d Z d Z dZxZS) Structurezs A high-level object wrapping a alloca'ed LLVM structure, including named fields and attribute access. NFcv|||_||_||_|vt ||jd|_|Wt |jrJ|j|jksJ|j|jf|||jn|Jt |jsJ|j|jj krT|r.| ||j }n$td|jj d|j||_i|_ g|_g|_t!d}t#|jD]U\}\}} ||j |<|j|t!|f|j| VdS)NTrqzmismatching pointer type: got z , expected r)get_struct_type_typerWr`rsrircrrhrebitcastrgr^_namemap_fdmap_typemapint32_tr"rJappend) rkrlrrrmcast_refrBr'rRtps rrozStructure.__init__s,,T22   ;%gtzFFFDK %ej11111zTZ///%*dj1I/// eT[111===ch'' ' ''zSX---:!//#tz/D/D/F/FGGCC#)8+++TZZ9:::DK   qzz#DL11 % %JAw2 DM!  K  gajj1 2 2 2 M  $ $ $ $ % %rc`|j|j|j|d}|S)NT)inbounds)r`geprir)rkr|rs rrzStructure._get_ptr_by_index&s,m T[-?$OO rcB||j|Sru)rr)rkrs rrzStructure._get_ptr_by_name*s%%dmH&=>>>rcp|ds||j|St|r)rrrrs rrzStructure.__getattr__-s:$$ ( e,- - '' 'rc|dr)tt|||S|||j|<dSr)rrrrrrs rrzStructure.__setattr__6sS   C  DD))55eUCC C%*T]5 !"""rc\|j||Sr)r`rrrs rrzStructure.__getitem__>s( }!!$"8"8"?"?@@@rc||}|jj|jkr@d}t||t |jjt |jfz|j||dS)rz:Type mismatch: __setitem__(%d, ...) expected %r but got %rN)rrrerfr<r`rh)rkr|rrfmts rrzStructure.__setitem__Es$$U++ 8 uz ) )NC (+CH,<(=(=(+EJ(9"9:: : E3'''''rc*t|jSr)r+rrs rrzStructure.__len__Qs4=!!!rc|jSr)rirs rrzStructure._getpointerWs {rc@|j|jSr)r`rrirs rrzStructure._getvalue]s}!!$+...rct|jrJ|j|jksJ|j|jf|j||jdS)z!Store the value in this structureN)rcrrr`rhrirs rrzStructure._setvaluecs^ej)))))zTZ'''%*dj)A''' E4;/////r)NNF)r;rrrrorrrrrrrrrrrrs@rrrs %%%%>???(((+++++AAA ( ( ("""  /// 0000000rrFct|trtjt|}t j|5|5||||}| |d|dddn #1swxYwY|r.| |j d||cdddS#1swxYwYdS)aAllocate stack memory at the entry block of the current function pointed by ``builder`` with llvm type ``ty``. The optional ``size`` arg set the number of element to allocate. The default is 1. The optional ``name`` arg set the symbol name inside the llvm IR for debugging. If ``zfill`` is set, fill the memory with zeros at the current use-site location. Note that the memory is always zero-filled after the ``alloca`` at init-site (the entry block). )sizenameN) rYintrr,intp_tr suspend_emissiongoto_entry_blockallocarhrre)rtyrrrrrs rrsrslsi$){64((  #G , ,  % % ' ' ) )..$T.::C MM""T((C ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) )  7 MM#(**400# 6 6 6s6C&8B C&B! !C&$B! %4C&&C*-C*c|d}|tdg}||tS)zCompute sizeof using GEP Nr )rrptrtointr)rptr_typenulloffsets rsizeofrs@ 8D>>D XXwqzzl # #F   FF + ++rc`t||j|}||||S)z Like alloca_once(), but passing a *value* instead of a type. The type is inferred and the allocated slot is also initialized with the given value. rq)rsrrh)rrrrrstorages ralloca_once_valuers3 '5:U;;;G MM%!!! Nrct|||}|jd|jd|S)z_ Insert a pure function (in the functional programming sense) in the given module. readonlynounwind)get_or_insert_function attributesaddmodulefntyrfns rinsert_pure_functionrsF d 3 3BMj!!!Mj!!! Ircl|j|d}|tj|||}|S)zm Get the function named *name* with type *fnty* from *module*, or insert it if it doesn't exist. N)globalsr8rFunctionrs rrrs8   D$ ' 'B z [t , , Ircx ||S#t$r||cYSwxYwru)get_named_metadataKeyErroradd_named_metadata)rrs rget_or_insert_named_metadatarsP/((... ///((...../s 99cZ||}tj||||Sru)get_unique_namerGlobalVariable)rrrr unique_names radd_global_variabler s,((..K VRi @ @@rcP|j}|j||dSdSru) basic_block terminatorbranch)rbbendbbs r terminaters2  B }urc|dSrur)ltypes rget_null_valuers 5;;rcXt|j}|d||S)N==rrrrr}rs ris_nullr) #( # #D  tS 1 11rcXt|j}|d||S)Nrrrs r is_not_nullrrrc0||dS)NFlikelyif_thenrpreds r if_unlikelyr%s ??4? . ..rc0||dS)NTrr!r#s r if_likelyr's ??4? - --rcR|||Sru)r"not_r#s rifnotr*s ??7<<-- . ..rc^|d}|||dgS)z# Increment an index *val*. r nsw)flags)rr)rr}ones rincrement_indexr/s/ ((1++C ;;sCw; / //rLoop)r|do_breakc#2 K||j}| |d}|}d}d}d fd}j}||5|d} d | |} | | dddn #1swxYwY|5t| |Vj}t| } t|dddn #1swxYwY| ||| | | dS) a Generate LLVM IR for a for-loop in [start, count). *start* is equal to 0 by default. Yields a Loop namedtuple with the following members: - `index` is the loop index's value - `do_break` is a no-argument callable to break out of the loop Nrfor.condfor.bodyfor.endc2dSru)r)rrsrr1zfor_range..do_breaksur loop.indexr<) rappend_basic_blockr r goto_blockphi icmp_signedcbranchr0r/r add_incomingposition_at_end) rcountstartintpstopbbcondbbbodyr1bbstartr|r$incrrs ` @r for_rangerIs; |z }Q D  ' ' 3 3F  ' ' 3 3F  & &y 1 1E!G NN6   F # #-- D| 44""3t44fe,,,---------------   F # ###5(#####$w..'6""" ############### ug&&& tV$$$ E"""""s%AC%%C),C):E  EETc#K||j}|d}|d}|d}|j} ||||5||d} ||d} |r|d| |} n|d | |} || ||dddn #1swxYwY||5| | fV|j}|| |} t|| }t||dddn #1swxYwY| || | | || tj |d | | ||||dS) a[ Generate LLVM IR for a for-loop based on a slice. Yields a (index, count) tuple where `index` is the slice index's value inside the loop, and `count` the iteration count. Parameters ------------- builder : object IRBuilder object start : int The beginning value of the slice stop : int The end value of the slice step : int The step value of the slice intp : The data type inc : boolean, optional Signals whether the step is positive (True) or negative (False). Returns ----------- None Nr3r4r5r7r8z loop.countr9>r)rr:r rr;r<r=r>rr/rr?rr,r@)rrBrDsteprCincrErFrrGr|rAr$rH next_counts rfor_range_slicerOs}4 |z  ' ' 3 3F  ' ' 3 3F  & &y 1 1E!G NN6   F # #-- D| 44 D| 44  9&&sE488DD&&sE488Dfe,,,---------------   F # ###Ul${{5$''$We44 '6""" ############### ug&&& tV$$$ r{4++W555 z6*** E"""""s&=rT)rMFc3|K|5|5}|Vdddn #1swxYwYddddS#1swxYwYdSrur)condinner_cmrs rcm_condz(for_range_slice_generic..cm_condbs    U                                  s$1 1 1 155rN)rr=rr,rOrif_else) rrBrDrLrC is_pos_step pos_for_range neg_for_rangerUthen otherwises rfor_range_slice_genericr\Ns9 :D%%dD"+dA2F2FGGK#GUD$$OOOM#GUD$%PPPM^ T 2 2N6GtYgdM**GGI},M,MMMMMNNNNNNNNNNNNNNNNNNsB00B47B4Cc#K|dvsJ|sdVdS|dkrd}nd}t||||5}t|t|ksJ||VddddS#1swxYwYdS)a Generate a loop nest walking a N-dimensional array. Yields a tuple of N indices for use in the inner loop body, iterating over the *shape* space. If *order* is 'C' (the default), indices are incremented inside-out (i.e. (0,0), (0,1), (0,2), (1,0) etc.). If *order* is 'F', they are incremented outside-in (i.e. (0,0), (1,0), (2,0), (0,1) etc.). This has performance implications when walking an array as it impacts the spatial locality of memory accesses. CFrFc|dddS)Nrxs rzloop_nest..sa"grc|Srurrcs rrezloop_nest..sarN) _loop_nestr+)rshaperCorder_swapindicess r loop_nestrlls D====  ! C<<%%EEKE ut 4 4 !w<<3u::----%..  ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !s0A55A9<A9c#$Kt||d|5}t|dkr?t||dd|5}|jf|zVdddn #1swxYwYn |jfVddddS#1swxYwYdS)NrrCr )rIr+rgr|)rrhrClooprks rrgrgs# 7E!H4 0 0 0 D u::>>GU122Y55 .zmg---- . . . . . . . . . . . . . . .:-                      s5-BA" B"A& &B)A& *BB  B ct|}| |dj}tj||tj}t |D]\}}||||}|S)z Pack a sequence of values in a LLVM array. *ty* should be given if the array may be empty, in which case the type can't be inferred from the values. Nr)r+rrr-r!r"r#)rr$rr1aryr'rs r pack_arrayrrsu F A z AY^ ",r1  bl + +C&!!..1""31-- Jrctjd|D}|tj}t|D]\}}||||}|S)z7 Pack a sequence of values into a LLVM struct. cg|] }|j Srrrs rrzpack_struct..s$<$<$<QV$<$<$.s9 # # #  ! !#q ) ) # # #r)r+relementsrange)rr{rAvalss`` r unpack_tuplersU }CH%&& # # # # #5\\ # # #D Krc t||j|j}t||j|j}t |||j|||j||| S)N)rA)r4rhstrideslayoutinds wraparound boundscheck)rrhndimrget_item_pointer2r4r) rlrarytyrqrrrshapesrs rget_item_pointerrsg '39EJ ? ? ?F7CKuzBBBG WgCHF%,U\(2  M M MMrc&fd}d}d}t|5tjr ||jt |fdddn #1swxYwYdd}t|5tjr ||jt |fddddS#1swxYwYdS)NcQttr'tddStddStddS)NzFdebug: IndexError: index %d is out of bounds for axis {} with size %d zFdebug: IndexError: index %d is out of bounds for axis %d with size %d z9debug: IndexError: index %d is out of bounds for size %d )rYrprintfr_)axisrdimlenindsr_dbgzdo_boundscheck.._dbgs  $$$ w!44:F4LL#vOOOOOw!458$ 7O     rzindex is out of boundsrQr9r)r=r%rFULL_TRACEBACKS call_convreturn_user_exc IndexErrorr) rlrrrrrmsgout_of_bounds_upperout_of_bounds_lowers ```` rdo_boundscheckrs        #C!--dC@@ W1 2 2GG  !  DFFF))':vFFFGGGGGGGGGGGGGGG"--c3 DD W1 2 2GG  !  DFFF))':vFFFGGGGGGGGGGGGGGGGGGs#9A;;A?A?9DD  D c "|rg} t||D]q\} } d| | d} | | } | | | }| |rn|} |r9t t| |D]\}\} } t|| | || s$|tdgS| dj}|dvrLg}|dkrftt|D]H}|d}||dzdD]} ||}||Inx|dkrctt|D]E}|d}|d|D]} ||}||Fntd|d}t| |D]1\}} ||}||}2||g}|Sfdt|| D}tjj|}t!||S) Nr9rr_r]r r` unreachablecBg|]\}}||Sr)mul)rsr'rs rrz%get_item_pointer2..s+GGGA7;;q!$$GGGr)zipr=rrselectrr"rrrr}r+r Exception functoolsreduce pointer_add)rlrr4rhrrrrrrkrrnegativewrappedselectedrrCstepsr'lastjlocrtmprdimoffsrs ` rrrs  tU++ % %KC**3SXXa[[AAHkk&#..G~~h==H NN8 $ $ $ $  % @#,S%-@-@#A#A @ @ D-3 7GS&$ ? ? ? ? /{{4'!**... 1:?D ~~ S==3u::&& # #tAwwq1uvv00A";;tQ//DD T""""  # s]]3u::&& # #tAwwrr00A";;tQ//DD T""""  # M** *d1gg'' ( (DAq++a##C++c3''CCkk$&& HGGGWg1F1FGGG!'+w777D&111rc<|d}t|jtjtjfr |||}nNt|jtjr||||}ntd|j|S)Nrzunexpected value type )rrYr FloatType DoubleTyper.r=r^)rrfpredicondnullvalisnulls r_scalar_pred_against_zerorsjjmmG%*r|R];<<Dug&& EJ + +D$$UE7;;iejjBCCC MrcVt||tj|jddS)zK Return a predicate representing whether *value* is equal to zero. rrrpartial fcmp_orderedrs ris_scalar_zeror's2 % )'*>EEt M MMrcVt||tj|jddS)z Return a predicate representing whether a *value* is not equal to zero. (not exactly "not is_scalar_zero" because of nans) rrrrfcmp_unorderedrs ris_not_scalar_zeror/2 % )'*@$GG O OOrcVt||tj|jddS)z] Return a predicate representing whether *value* is equal to either zero or NaN. rrrs ris_scalar_zero_or_nanr8rrcVt||tj|jddS)z: Is *value* negative? Assumes *value* is signed. r9rrs r is_scalar_negrEs2 % )'*>DDc K KKrstackc#K|||d\}}|5dVdddn #1swxYwY||dS)a The Python code:: with contextlib.ExitStack() as stack: with early_exit_if(builder, stack, cond): cleanup() body() emits the code:: if (cond) { } else { } This can be useful for generating code with lots of early exits, without having to increase the indentation each time. FrN) enter_contextrV)rrrSrZr[s r early_exit_ifrMs,))'//$u/*M*MNNOD)    """""sAA Ac@t||t||S)z A convenience wrapper for :func:`early_exit_if`, for the common case where the CPython API indicates an error by returning ``NULL``. )rr)rrobjs rearly_exit_if_nullris %#)>)> ? ??rc|t||d5|d}|ddpd}|j|||ddddS#1swxYwYdS)zu Guard against *value* being null or zero. *exc_tuple* should be a (exception type, arguments...) tuple. Frrr N)r"rrr)rlrr exc_tupleexcexc_argss r guard_nullrqs 77 F FBBlQRR=(D))'3AAABBBBBBBBBBBBBBBBBBs1A$$A(+A(c.t|jtjsJ|j|r|fnd}|t ||d5|j|t|ddddS#1swxYwYdS)zG Guard against *pointer* being NULL (and raise a MemoryError). rFrN) rYrr PointerTyper"rrr MemoryError)rlrpointerrrs rguard_memory_errorr|s glBN 3 3AAW\AA 3$vv"H '225 A AJJ))';IIIJJJJJJJJJJJJJJJJJJs"B  BBc#K|t|||5dVddddS#1swxYwYdS)z> Execute the given block if the scalar value is zero. rN)r"r)rrr s rif_zerors 77 G G s :>>c6t|tjS)z7 Whether the LLVM type *typ* is a struct type. )rYrr)ltyps rrcrcs dBN + ++rct||d|}t|jjrJ|||Sr)rrcrrerrg)rrecordrtyppvals rget_record_memberrsL F 3 3D$)+,,,, , ??4!1!1 2 22rcV|d||dS)Nr9r)r=r)rr}s r is_neg_intrs$   sC! 5 55rc(t||g|Rddi|S)z8 Same as *gep*, but add the `inbounds` keyword. rT)r)rrrkwss rrrs) w 9d 9 9 9T 9S 9 99rc|dd}|dd}|rJg}|D]>}t|trt|}n|}||?|||||S)z Emit a getelementptr instruction for the given pointer and indices. The indices can be LLVM values or Python int constants. rrrF)rr)rKrYrrrr) rrrrrridxr'rs rrrs 7762  Dwwz5))HNN7 C  a   !**CCC 3 ;;sCdX; > >>rc t|trt|}||t}|||g}|||p|jS)ax Add an integral *offset* to pointer *ptr*, and return a pointer of *return_type* (or, if omitted, the same type as *ptr*). The computation is done in bytes (ignoring the width of the pointed item type) via a byte-wise getelementptr, so the result keeps the provenance of *ptr*. Only valid when *offset* stays within the object *ptr* points into. )rYrrrint8_trgrr)rrr return_typerBaddrs rrrsp&#  ??3 1 1 3 3 4 4D ;;tfX & &D ??4!8 9 99rc  |jdt|jf}||t}t |t rt|}|||||tdgdS)z= Fill *size* bytes starting from *ptr* with *value*. z llvm.memsetrN) rdeclare_intrinsic voidptr_trrrYrrcallbool_t)rrrrrs rmemsetrs{  ) )-)TY9O P PB //#y ) )C%u  LLc5$q 233333rc||}t||t||jd|||dS)z7 Fill padding bytes of the pointee with zeros. rN)rrrrrh)rrr}s rmemset_paddingrsO ,,s  C 7C22A666 MM#srinternalct|tjr|}n|j}t ||j|}||_d|_||_|S)zO Get or create a (LLVM module-)global constant with *name* or *value*. T) rYrModulerr rlinkageglobal_constant initializer)builder_or_modulerrrrr4s rrrsW#RY//*"") vuz4 8 8DDLDD Krc|dksJ||}|d}t||j}|t||5\}}|5|||}|||dddn #1swxYwY|5|||}|||}|||||dddn #1swxYwYdddn #1swxYwY||}||| ||} || fS)a  Compute the (quotient, remainder) of *val* divided by the constant positive *divisor*. The semantics reflects those of Python integer floor division, rather than C's / LLVM's signed division and modulo. The difference lies with a negative *val*. rr N) rrsrVrsdivrhrsubrr) rr}divisorr.quotif_negif_posquot_val val_plus_onerem_vals rdivmod_by_constantrs Q;;;;hhwG ((1++C w ) )D GS11 2 2 <6Fvv  * *||C11H MM(D ) ) ) * * * * * * * * * * * * * * * < <";;sC00L||L'::H MM'++h44d ; ; ;  < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <||D!!Hkk#w{{8W==>>G W s[+D11-B* D1*B. .D11B. 2D17AD D1D D1!D "D11D58D5c|d}|||||||S)z Branch conditionally or continue. Note: a new block is created and builder is moved to the end of the new block. z .continue)r:r>r@)rrSbbtruebbconts rcbranch_or_continuersF ' ' 4 4F OOD&&))) F### MrcL|j|jksJt|||j5}|||jg}|||jg}||||ddddS#1swxYwYdS)z Emit a memcpy to the builder. Copies each element of dst to src. Unlike the C equivalent, each element can be any LLVM type. Assumes ------- * dst.type == src.type * count is positive rnN)rrIrr|rhr)rrOrPrAroout_ptrin_ptrs rmemcpyr  s 8sx     7E 3 3 35t++cDJ<00S4:,// gll6**G444555555555555555555sA"BB Bc |j}t|trtj||}|j|tt|g}t} | || |t| |t| ||| gdSru) rrYrrr,rrr false_bitrrr) r func_namerOrPrAitemsizealignsize_tr  is_volatiles r _raw_memcpyr5s ZF(C  1;vx00 ^ - -i/8)V.LNNFK LL'//#y99!//#y99!++eX66%'(((((rc ,t|d|||||S)za Emit a raw memcpy() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memcpyrrrOrPrAr rs r raw_memcpyrCs w sC% P PPrc ,t|d|||||S)zb Emit a raw memmove() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memmoverrs r raw_memmoverKs% wS% ( ((rc:|||}||d}||d}|||}||d}||||d} || fS)zq Compute (a * b + c) and return a (result, overflow bit) pair. The operands must be signed integers. rr )smul_with_overflowrzsadd_with_overflowor_) rar0cpprodprod_ovfrrAovfs rmuladd_with_overflowr"Ts ""1a((A  A & &D$$Q**H""4++A   1 % %C ++h 5 5a ; ; < rgs 00000000666666666666 A A "*R.. E& ' '      6!99 F1II F1II VAYY ===    :::&"B0B0B0B0B06B0B0B0J     |    1 1 1 1 1l 1 1 1 g0g0g0g0g0g0g0g0X2,,,///AAAA  222 222 ///...///000{f&;<<(#(#(#(#V6#6#6#6#rNNN:!!!!6           EJ!& M M M MGGGG>5:72727272tMMMOOOOOO  KKK#)####6@@@BBBJJJJ ,,,333 666:::???&::::"444       >   555* ( ( (QQQQ((((   4444CCC4   000.88888r