B \@sdZddlmZmZmZddlZddlmZddlZddl m Z ddl m Z m Z e dZe dZe d Ze e jZeZedZedZedZedZd d Zdd d ZddZiZdddZifddZGddde Z!Gddde!Z"Gddde!Z#Gddde Z$ddd Z%dd!d"Z&d#d$Z'd%d&Z(d'd(Z)d)d*Z*d+d,Z+d-d.Z,d/d0Z-d1d2Z.d3d4Z/e0d5d6Z1edd7d8Z2edd:d;Z3eddSdTZ?e>Z@e=ZAdUdVZBdWdXZCddYdZZDedd[d\ZEeCZFd]d^ZGd_d`ZHdadbZIdcddZJdedfZKddgdhZLdidjZMddldmZNdndoZOdpdqZPdrdsZQdtduZRddvdwZSddxdyZTdzd{ZUd|d}ZVd~dZWddZXe jYrddZZnddZZddZ[dS)z+ Generic helpers for LLVM code generation. )print_functiondivisionabsolute_importN)contextmanager)ir)utilsconfig cCs|d||dS)Nz!=r) icmp_unsignedtype)buildervaluer,lib/python3.7/site-packages/numba/cgutils.py as_bool_bitsrcCsN|dkrtdd|D}|tj}x"t|D]\}}||||}q0W|S)zH Create an anonymous struct containing the given LLVM *values*. NcSsg|] }|jqSr)r ).0vrrr %sz)make_anonymous_struct..)rLiteralStructType Undefined enumerate insert_value)rvaluesZ struct_typeZ struct_valirrrrmake_anonymous_struct s  rcCs*t|}t|}tttd||S)z0 Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)Zbufbnrrrmake_bytearray,sr$rcCsb||f}t|}|dkr^ttd|}|jdt|}|f}t|d}t|||}|t|<|S)zK Returns a specialized StructProxy subclass for the given fe_type. N)rdata_)_fe_type)_struct_proxy_cachegetValueStructProxyDataStructProxy__name__strdictr )Zfe_typeZkindZ cache_keyresbaseZclsnamebasesZ clsmembersrrrcreate_struct_proxy8s   r2cCs^|}x.|jjD]"}||t||}t|||qWx |D]\}}t|||qBW|S)zJ Copy structure from *src* to *dst* with replacement from *repl*. )copy _datamodel_fieldspopgetattrsetattritems)dstsrcreplkrrrr copy_structKsr>cseZdZdZdZd!ddZddZddZd d Zd d Z d dZ ddZ ddZ fddZ ddZddZddZddZddZdd ZZS)" _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. NcCsddlm}||_|jj|j|_t|j|js@td |j||_ | |j|_ t |j rbt||\}}|jj|j krtd|j |jf|dk r|j|jjkrtd|jj|jf|j ||||_||_dS)Nr) datamodelzNot a structure model: {0}z!bad ref type: expected %s, got %sz#bad value type: expected %s, got %s)Znumbar@_contextZdata_model_managerr'r4 isinstanceZ StructModel TypeErrorformat_builder _get_be_type_be_type is_pointerAssertionError _make_refsr pointee as_pointerstore_value _outer_ref)selfcontextrrrefr@Z outer_refrrr__init__cs& z_StructProxy.__init__cCs"|dkrt|j|jdd}||fS)z Return an (outer ref, value ref) pair. By default, these are the same pointers, but a derived class may override this. NT)zfill) alloca_oncerErG)rPrRrrrrJ|sz_StructProxy._make_refscCstdS)N)NotImplementedError)rPr@rrrrFsz_StructProxy._get_be_typecCstdS)N)rV)rPindexvalrrr_cast_member_to_valuesz"_StructProxy._cast_member_to_valuecCstdS)N)rV)rPrWrXrrr_cast_member_from_valuesz$_StructProxy._cast_member_from_valuecCst|j|jd|S)Nr) gep_inboundsrErN)rPrWrrr_get_ptr_by_indexsz_StructProxy._get_ptr_by_indexcCs|j|}||S)N)r4get_field_positionr\)rPattrnamerWrrr_get_ptr_by_names z_StructProxy._get_ptr_by_namecCs&|ds||j|St|dS)z; Load the LLVM value of the named *field*. r&N) startswithr4r]AttributeError)rPfieldrrr __getattr__s z_StructProxy.__getattr__cs0|drtt|||S|||j|<dS)z@ Store the LLVM *value* into the named *field*. r&N)r`superr? __setattr__r4r])rPrbr) __class__rrres z_StructProxy.__setattr__cCs|j||}|||S)z> Load the LLVM value of the field at *index*. )rEloadr\rY)rPrWZ member_valrrr __getitem__sz_StructProxy.__getitem__cCs||}|||}|j|jjkr|t|jrft|jjrf|jj|jjjkrf|j|j||jjj}nt dj ||||d|j ||dS)zC Store the LLVM *value* into the field at *index*. zjInvalid store of {value.type} to {ptr.type.pointee} in {self._datamodel} (trying to write member #{index}))rptrrPrWN) r\rZr rKrHrAZ addrspacecastrEZ addrspacerCrDrM)rPrWrrirrr __setitem__s    z_StructProxy.__setitem__cCs|jjS)z. Return the number of fields. )r4Z field_count)rPrrr__len__sz_StructProxy.__len__cCs|jS)zF Return the LLVM pointer to the underlying structure. )rO)rPrrr _getpointersz_StructProxy._getpointercCs|j|jS)zM Load and return the value of the underlying LLVM structure. )rErgrO)rPrrr _getvaluesz_StructProxy._getvaluecCs>t|jrt|j|jks*t|j|jf|j||jdS)z4 Store the value in this structure. N)rHr rIrGrErMrN)rPrrrr _setvaluesz_StructProxy._setvalue)NN)r, __module__ __qualname____doc__r'rSrJrFrYrZr\r_rcrerhrjrkrlrmrn __classcell__rr)rfrr?Zs"   r?c@s(eZdZdZddZddZddZdS) r*zl Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). cCs|S)N)Zget_value_type)rPr@rrrrFszValueStructProxy._get_be_typecCs|S)Nr)rPrWrXrrrrYsz&ValueStructProxy._cast_member_to_valuecCs|S)Nr)rPrWrXrrrrZsz(ValueStructProxy._cast_member_from_valueN)r,rorprqrFrYrZrrrrr*sr*c@s(eZdZdZddZddZddZdS) r+zO Create a StructProxy suitable for accessing data persisted in memory. cCs|S)N)Z get_data_type)rPr@rrrrFszDataStructProxy._get_be_typecCs|j|}||j|S)N)r4 get_modelZ from_datarE)rPrWrXmodelrrrrYs z%DataStructProxy._cast_member_to_valuecCs|j|}||j|S)N)r4rsZas_datarE)rPrWrXrtrrrrZs z'DataStructProxy._cast_member_from_valueN)r,rorprqrFrYrZrrrrr+sr+csreZdZdZdddZddZdd Zd d Zfd d ZddZ ddZ ddZ ddZ ddZ ddZZS) Structurezs A high-level object wrapping a alloca'ed LLVM structure, including named fields and attribute access. NFc Cs4|||_||_||_|dkrtt||jdd|_|dk rt|jrHt|j|jksdt|j|jf| ||jn\|dkstt|jst|j|jj kr|r| ||j }nt d|jj |jf||_i|_g|_g|_td}xDt|jD]6\}\}} ||j|<|j|t|f|j| qWdS)NT)rTz-mismatching pointer type: got %s, expected %sr)Zget_struct_type_typerArErUrNrHr rIrMrKbitcastrLrC_namemap_fdmapZ_typemapint32_trr5append) rPrQrrrRZcast_refr0rr=tprrrrSs4   zStructure.__init__cCs|jj|j|j|dd}|S)NT)inbounds)rEgeprNry)rPrWrirrrr\$szStructure._get_ptr_by_indexcCs||j|S)N)r\rx)rPr^rrrr_(szStructure._get_ptr_by_namecCs$|ds||j|St|dS)z; Load the LLVM value of the named *field*. r&N)r`rxra)rPrbrrrrc+s zStructure.__getattr__cs.|drtt|||S|||j|<dS)z@ Store the LLVM *value* into the named *field*. r&N)r`rdrurerx)rPrbr)rfrrre4s zStructure.__setattr__cCs|j||S)z> Load the LLVM value of the field at *index*. )rErgr\)rPrWrrrrh<szStructure.__getitem__cCsN||}|jj|jkrt|jrt|j|jks*t|j|jf|j||jdS)z!Store the value in this structureN)rHr rIrvrErMrN)rPrrrrrnaszStructure._setvalue)NNF)r,rorprqrSr\r_rcrerhrjrkrlrmrnrrrr)rfrrus   ruFc Csht|tjrtt|}|*|j|||d}|rF||d|WdQRX|rd||d||S)aaAllocate stack memory at the entry block of the current function pointed by ``builder`` withe 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, also filling zeros to the memory. )sizenameN) rBr INT_TYPESrrintp_tZgoto_entry_blockZallocarM)rtyrrrTrirrrrUjs   rUcCst||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. )rUr rM)rrrZstoragerrralloca_once_value~s  rcCs*|j||d}|jd|jd|S)z_ Insert a pure function (in the functional programming sense) in the given module. )rreadonlyZnounwind)Zget_or_insert_functionZ attributesadd)modulefntyrfnrrrinsert_pure_functions  rcCs|j}|jdkr||dS)N) basic_block terminatorbranch)rbbendZbbrrr terminates rcCs|dS)Nr)Zltyperrrget_null_valuesrcCst|j}|d||S)Nz==)rr r )rrXnullrrris_nulls rcCst|j}|d||S)Nz!=)rr r )rrXrrrr is_not_nulls rcCs|j|ddS)NF)likely)if_then)rpredrrr if_unlikelysrcCs|j|ddS)NT)r)r)rrrrr if_likelysrcCs|||S)N)rnot_)rrrrrifnotsrcCs|d}|j||dgdS)z# Increment an index *val*. rZnsw)flags)r r)rrXonerrrincrement_indexs rLoop)rWdo_breakc #s|dkr|j}|dkr|d}|}d}d}dfdd}j}||0j|dd } d | |} | |WdQRX|,t| |Vj}t | } t |WdQRX| ||| | | 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 Nrzfor.condzfor.bodyzfor.endcsdS)N)rr)rrrrrszfor_range..do_breakz loop.index)r<) r append_basic_blockrr goto_blockphi icmp_signedcbranchrrr add_incomingposition_at_end) rcountstartintpstopbbcondbbbodyrbbstartrWrincrr)rrr for_ranges.           rTc cs*|dkr|j}|d}|d}|d}|j} ||||R|j|dd} |j|dd} |rx|d| |} n|d | |} || ||WdQRX||6| | fV|j}|| |} t || }t ||WdQRX| || | | || t |d | | ||||dS) aY 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 Builder 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 Nzfor.condzfor.bodyzfor.endz loop.index)rz loop.countr>r)r rrrrrrrrrrrrrr)rrrsteprincrrrrrWrrrZ next_countrrrfor_range_slices2            rc cs|j}|d|t|d}t|||||dd}t|||||dd}tdd}|j|dd \} } || ||| |fVWd QRXd S) a A helper wrapper for for_range_slice(). This is a context manager which yields two for_range_slice()-alike context managers, the first for the positive step case, the second for the negative step case. Use: with for_range_slice_generic(...) as (pos_range, neg_range): with pos_range as (idx, count): ... with neg_range as (idx, count): ... z>=rT)rFc ss*|| }|VWdQRXWdQRXdS)Nr)condZinner_cmrrrrcm_cond<sz(for_range_slice_generic..cm_cond)rN)r rrrrrif_else) rrrrrZ is_pos_stepZ pos_for_rangeZ neg_for_rangerZthenZ otherwiserrrfor_range_slice_generic(s rCc csp|dks t|sdVnT|dkr*dd}ndd}t||||$}t|t|ksXt||VWdQRXdS)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. CFrFcSs|dddS)Nr)xrrrZszloop_nest..cSs|S)Nr)rrrrr\sN)rI _loop_nestr)rshaperorderZ_swapindicesrrr loop_nestFs  rc csht||d|dL}t|dkrPt||dd|}|jf|VWdQRXn |jfVWdQRXdS)Nr)rr)rrrrW)rrrlooprrrrrbs  rcCsTt|}|dkr|dj}t||tj}x"t|D]\}}||||}q6W|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)rr rr rrr)rrrr#aryrrrrr pack_arrayls rcCsFtdd|D}|tj}x"t|D]\}}||||}q(W|S)z7 Pack a sequence of values into a LLVM struct. cSsg|] }|jqSr)r )rrrrrrszpack_struct..)rrrrr)rrZstructtystrrrrr pack_struct{s  rcs0|dkrtjj}fddt|D}|S)zH Unpack an array or structure of values, return a Python tuple. Ncsg|]}|qSr) extract_value)rr)rtuprrrsz unpack_tuple..)rr elementsrange)rrrZvalsr)rrr unpack_tuples    rc Cs>t||j|jd}t||j|jd}t||j|||j||dS)N)r)r%rstrideslayoutinds wraparound)rrndimrget_item_pointer2r%r)rZarytyrrrZshapesrrrrget_item_pointers  rcs|rZg}xTt||D]@\}} d||d} | |} | | |} || qWn|}|st|tdgS|dj} |dkrg}|dkrxtt |D]<}| d}x$||ddD]} ||}qW||qWn`|dkr.)ziprr rZselectr{r~rzrrr Exception functoolsreduce pointer_add)rr%rrrrrrindZdimlennegativewrappedZselectedrZstepsrZlastjZlocrZtmpriZdimoffsoffsetr)rrrsF     rcCs\|d}t|jtjtjfr*|||}n.t|jtjrH||||}ntd|jf|S)Nrzunexpected value type %s)r rBrZ FloatTypeZ DoubleTyper!rrC)rrZfpredZicondZnullvalZisnullrrr_scalar_pred_against_zeros  rcCst||t|jddS)zK Return a predicate representing whether *value* is equal to zero. z==)rrpartial fcmp_ordered)rrrrris_scalar_zerosrcCst||t|jddS)z Return a predicate representin whether a *value* is not equal to zero. (not exactly "not is_scalar_zero" because of nans) z!=)rrrfcmp_unordered)rrrrris_not_scalar_zerosrcCst||t|jddS)z] Return a predicate representing whether *value* is equal to either zero or NaN. z==)rrrr)rrrrris_scalar_zero_or_nansrcCst||t|jddS)z: Is *value* negative? Assumes *value* is signed. r)rrrr)rrrrr is_scalar_negsrc CsL|jt||dd.|d}|ddp,d}|j|||WdQRXdS)zu Guard against *value* being null or zero. *exc_tuple* should be a (exception type, arguments...) tuple. F)rrrN)rr call_convreturn_user_exc)rQrrZ exc_tupleexcexc_argsrrr guard_nullsrc CsZt|jtjst|j|r"|fnd}|jt||dd|j|t |WdQRXdS)zG Guard against *pointer* being NULL (and raise a MemoryError). rF)rN) rBr r PointerTyperIrrrr MemoryError)rQrZpointermsgrrrrguard_memory_error src cs*|jt|||d dVWdQRXdS)z> Execute the given block if the scalar value is zero. )rN)rr)rrrrrrif_zerosrcCs t|tjS)z7 Whether the LLVM type *typ* is a struct type. )rBrr)ZltyprrrrHsrHcCs.t||d|}t|jjrt|||S)Nr)r[rHr rKrIrwrL)rrecordrtypZpvalrrrget_record_member&srcCs|d||dS)Nrr)rr )rrXrrr is_neg_int,srcOst||f|ddi|S)z8 Same as *gep*, but add the `inbounds` keyword. r}T)r~)rrirkwsrrrr[0sr[c Osh|dd}|dd}|r tg}x0|D](}t|tjrDt|}n|}||q*W|j||||dS)z Emit a getelementptr instruction for the given pointer and indices. The indices can be LLVM values or Python int constants. rrr}F)rr})r6rIrBrrrzr{r~) rrirrrr}idxrrrrrr~7s     r~cCs>||t}t|tjr t|}|||}|||p:|jS)z Add an integral *offset* to pointer *ptr*, and return a pointer of *return_type* (or, if omitted, the same type as *ptr*). Note the computation is done in bytes, and ignores the width of the pointed item type. )ZptrtointrrBrrrZinttoptrr )rrirZ return_typeZintptrrrrrJs    rc CsT|jdt|jf}||t}t|tr2t|}|||||t dt dgdS)z= Fill *size* bytes starting from *ptr* with *value*. z llvm.memsetrN) rdeclare_intrinsic voidptr_tr rwrBintint8_tcallrzbool_t)rrirrrrrrmemsetYs   rinternalcCs>t|tjr|}n|j}|j|j|d}||_d|_||_|S)zO Get or create a (LLVM module-)global constant with *name* or *value*. )rT) rBrZModulerZadd_global_variabler linkageglobal_constantZ initializer)Zbuilder_or_modulerrrrr%rrrrds rc Cs|dks t||}|d}t||j}|t||n\}}||||}|||WdQRX|2|||}|||}|||||WdQRXWdQRX| |}||| ||} || 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*. rrN) rIr rUrrZsdivrMrsubrgr) rrXZdivisorrZquotZif_negZif_posZquot_valZ val_plus_oneZrem_valrrrdivmod_by_constantss       ( rcCs&|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)rrr)rrZbbtrueZbbcontrrrcbranch_or_continues  rc Csb|j|jkstt|||jd8}|||jg}|||jg}||||WdQRXdS)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 )rN)r rIrr~rWrMrg)rr:r;rrZout_ptrZin_ptrrrrmemcpys rc Csz|j}t|tjrt||}|j|tt|g}tt d|}t } | || |t| |t| |||| gdS)Nr )r rBrrrrrrrr! false_bitrrwr) rZ func_namer:r;ritemsizealignZsize_trZ is_volatilerrr _raw_memcpys     r cCst|d|||||S)za Emit a raw memcpy() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memcpy)r )rr:r;rr r rrr raw_memcpysr cCst|d|||||S)zb Emit a raw memmove() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memmove)r )rr:r;rr r rrr raw_memmovesr c CsX|||}||d}||d}|||}||d}||||d} || fS)zq Compute (a * b + c) and return a (result, overflow bit) pair. The operands must be signed integers. rr)Zsmul_with_overflowrZsadd_with_overflowor_) rar"cpZprodZprod_ovfrr/Zovfrrrmuladd_with_overflows     rc Gst|tst|j}t}t|dd}t|d|}tj t |gdd}y| d}Wn$t k rztj ||dd}YnX|||} ||| gt|S)a Calls printf(). Argument `format` is expected to be a Python string. Values to be printed are listed in `args`. Note: There is no checking to ensure there is correct number of values in `args` and there type matches the declaration in the format string. asciiZ printf_formatT)var_argprintf)r)rBr-rIrrr$encoderr FunctionTyperz get_globalKeyErrorFunctionrwrlist) rrDargsmodcstring fmt_bytes global_fmtrrptr_fmtrrrrs   rc Gst|tst|j}t}t|dd}t|d|}tj t |t |gdd} d} t j r^d| } y|| } Wn$tk rtj|| | d} YnX|||} || ||| gt|S) z8Calls libc snprintf(buffer, bufsz, format, ...args) rrZsnprintf_formatT)rsnprintfr&)r)rBr-rIrrr$rrrrrzrr ZIS_WIN32rrrrwrr) rbufferbufszrDrrrr r!rZsymbolrr"rrrr#s   r#cGsVt|tstttd|}t||dd}||t}t ||t ||f||S)zwSimilar to `snprintf()` but the buffer is stack allocated to size *bufsz*. Returns the buffer pointer as i8*. r T)rT) rBrrIrr r!rUrwrr#r)rr%rDrZspacetyZspacer$rrrsnprintf_stackbuffers  r&cCs|ddS)zw Normalize the given string to latin1 compatible encoding that is suitable for use in LLVM IR. utf8latin1)rdecode)textrrrnormalize_ir_text$sr+cCs|S)zI No-op for python2. Assume there won't be unicode names. r)r*rrrr+,sc Csd}||t}t|d||td}|||}t||p}||j t|}| d|td}| |t|dWdQRX| ||j g}| |} t|d| WdQRXt|ddS) zIDebug print the memory region in *ptr* to *ptr + nbytes* as hex. zhexdump p=%p n=%zur z==r Nz %02x)Zzextrrrr!rwrLrZuremrWr rr~rg) rrinbytesZbytes_per_lineZbyte_trZdiv_byZ do_new_linerrXrrrhexdump3s     r/)N)r)NrF)r)NN)NT)r)N)N)F)F)N)F)N)r)r)r)\rqZ __future__rrr collections contextlibrrZllvmliterrrr r!rrrzZ MACHINE_BITSrrLrZtrue_bitrZ true_byteZ false_byterrr$r(r2r>objectr?r*r+rurUrrrrrrrrrr namedtuplerrrrrrrrrrrrrrrZis_trueZis_falserrrrZ guard_zerorHrrr[r~rrrrrrr r r rrr#r&ZPY3r+r/rrrrs          l     + 9    2