3 VY]W@sdZddlmZmZmZddlZddlmZddlZddl m Z ddl m Z e j dZe j dZe j d Ze j e jZejZedZedZedZedZd d Zdd d ZddZiZdddZifddZGdddeZ Gddde Z!Gddde Z"GdddeZ#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.ej/d5dZ0edd8d9Z1edd;d<Z2ed=d>Z3edd@dAZ4edBdCZ5ddDdEZ6ddFdGZ7ddHdIZ8ddJdKZ9dLdMZ:dNdOZ;dPdQZe;Z?dTdUZ@dVdWZAddXdYZBeddZd[ZCeAZDd\d]ZEd^d_ZFd`daZGdbdcZHdddeZIddfdgZJdhdiZKddkdlZLdmdnZMdodpZNdqdrZOdsdtZPddudvZQddwdxZRdydzZSd{d|ZTe jUrd}d~ZVndd~ZVddZWdS)z+ Generic helpers for LLVM code generation. )print_functiondivisionabsolute_importN)contextmanager)ir)utils cCs|jd||jdS)Nz!=r) icmp_unsignedtype)buildervaluer,lib/python3.6/site-packages/numba/cgutils.py as_bool_bitsrcCsN|dkrtjdd|D}|tj}x"t|D]\}}|j|||}q0W|S)zH Create an anonymous struct containing the given LLVM *values*. NcSsg|] }|jqSr)r ).0vrrr %sz)make_anonymous_struct..)rZLiteralStructType Undefined enumerate insert_value)r valuesZ struct_typeZ struct_valirrrrmake_anonymous_struct s  rcCs*t|}t|}tjtjtjd||S)z0 Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)Zbufbnrrrmake_bytearray,sr"rcCsb||f}tj|}|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_proxy7s   r0cCs^|j}x.|jjD]"}|j|t||}t|||qWx |jD]\}}t|||qBW|S)zJ Copy structure from *src* to *dst* with replacement from *repl*. )copy _datamodel_fieldspopgetattrsetattritems)dstsrcreplkrrrr copy_structJsr<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@tdj |j||_ |j |j|_ t |j  sdt|j|\}}|jj|j krtd|j j|jf|dk r|j|jjkrtd|jj|jf|j 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%r2 isinstanceZ StructModel TypeErrorformat_builder _get_be_type_be_type is_pointerAssertionError _make_refsr pointee as_pointerstore_value _outer_ref)selfcontextr rrefr>Z outer_refrrr__init__bs& 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_oncerCrE)rNrPrrrrH{sz_StructProxy._make_refscCstdS)N)NotImplementedError)rNr>rrrrDsz_StructProxy._get_be_typecCstdS)N)rT)rNindexvalrrr_cast_member_to_valuesz"_StructProxy._cast_member_to_valuecCstdS)N)rT)rNrUrVrrr_cast_member_from_valuesz$_StructProxy._cast_member_from_valuecCst|j|jd|S)Nr) gep_inboundsrCrL)rNrUrrr_get_ptr_by_indexsz_StructProxy._get_ptr_by_indexcCs|jj|}|j|S)N)r2get_field_positionrZ)rNattrnamerUrrr_get_ptr_by_names z_StructProxy._get_ptr_by_namecCs&|jds||jj|St|dS)z; Load the LLVM value of the named *field*. r$N) startswithr2r[AttributeError)rNfieldrrr __getattr__s z_StructProxy.__getattr__cs0|jdrtt|j||S|||jj|<dS)z@ Store the LLVM *value* into the named *field*. r$N)r^superr= __setattr__r2r[)rNr`r) __class__rrrcs z_StructProxy.__setattr__cCs|jj|j|}|j||S)z> Load the LLVM value of the field at *index*. )rCloadrZrW)rNrUZ member_valrrr __getitem__sz_StructProxy.__getitem__cCs|j|}|j||}|j|jjkr|t|jrft|jjrf|jj|jjjkrf|jj|j||jjj}nt dj ||||d|jj ||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}))rptrrNrUN) rZrXr rIrFr?Z addrspacecastrCZ addrspacerArBrK)rNrUrrgrrr __setitem__s    z_StructProxy.__setitem__cCs|jjS)z. Return the number of fields. )r2Z field_count)rNrrr__len__sz_StructProxy.__len__cCs|jS)zF Return the LLVM pointer to the underlying structure. )rM)rNrrr _getpointersz_StructProxy._getpointercCs|jj|jS)zM Load and return the value of the underlying LLVM structure. )rCrerM)rNrrr _getvaluesz_StructProxy._getvaluecCs@t|j st|j|jks,t|j|jf|jj||jdS)z4 Store the value in this structure. N)rFr rGrErCrKrL)rNrrrr _setvaluesz_StructProxy._setvalue)NN)r* __module__ __qualname____doc__r%rQrHrDrWrXrZr]rarcrfrhrirjrkrl __classcell__rr)rdrr=Ys"   r=c@s(eZdZdZddZddZddZdS) r(zl Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). cCs|jS)N)Zget_value_type)rNr>rrrrDszValueStructProxy._get_be_typecCs|S)Nr)rNrUrVrrrrWsz&ValueStructProxy._cast_member_to_valuecCs|S)Nr)rNrUrVrrrrXsz(ValueStructProxy._cast_member_from_valueN)r*rmrnrorDrWrXrrrrr(sr(c@s(eZdZdZddZddZddZdS) r)zO Create a StructProxy suitable for accessing data persisted in memory. cCs|jS)N)Z get_data_type)rNr>rrrrDszDataStructProxy._get_be_typecCs|jj|}|j|j|S)N)r2 get_modelZ from_datarC)rNrUrVmodelrrrrWs z%DataStructProxy._cast_member_to_valuecCs|jj|}|j|j|S)N)r2rqZas_datarC)rNrUrVrrrrrrXs z'DataStructProxy._cast_member_from_valueN)r*rmrnrorDrWrXrrrrr)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 Cs2|j||_||_||_|dkrrt||j|_|dk rt|j sFt|j|jksbt|j|jf|j ||jn\|dks~tt|jst|j|jj kr|r|j ||jj }nt d|jj |jf||_i|_g|_g|_td}xDt|jD]6\}\}} ||j|<|jj|t|f|jj| qWdS)Nz-mismatching pointer type: got %s, expected %sr)Zget_struct_type_typer?rCrSrLrFr rGrKrIbitcastrJrA_namemap_fdmapZ_typemapint32_trr3append) rNrOr rrPZcast_refr.rr;tprrrrQs4   zStructure.__init__cCs|jj|j|j|dd}|S)NT)inbounds)rCgeprLrw)rNrUrgrrrrZ#szStructure._get_ptr_by_indexcCs|j|j|S)N)rZrv)rNr\rrrr]'szStructure._get_ptr_by_namecCs$|jds||j|St|dS)z; Load the LLVM value of the named *field*. r$N)r^rvr_)rNr`rrrra*s zStructure.__getattr__cs.|jdrtt|j||S|||j|<dS)z@ Store the LLVM *value* into the named *field*. r$N)r^rbrsrcrv)rNr`r)rdrrrc3s zStructure.__setattr__cCs|jj|j|S)z> Load the LLVM value of the field at *index*. )rCrerZ)rNrUrrrrf;szStructure.__getitem__cCsN|j|}|jj|jkr.do_breakz loop.index)r<) r append_basic_blockrr goto_blockphi icmp_signedcbranchrrr add_incomingposition_at_end) r countstartintpstopbbcondbbbodyrbbstartrUrincrr)rr r for_ranges.           rTccs*|dkr|j}|jd}|jd}|jd}|j} |j||j|R|j|dd} |j|dd} |rx|jd| |} n|jd | |} |j| ||WdQRX|j|6| | fV|j}|j| |} t || }t ||WdQRX| j || | j | || j t j |d | | j |||j|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)r rrsteprincrrrrrUrrrZ next_countrrrfor_range_slices2            rc cs|j}|jd|tj|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)rFcss*|| }|VWdQRXWdQRXdS)Nr)condZinner_cmrrrrcm_cond6sz(for_range_slice_generic..cm_cond)rN)r rrrrrif_else) r rrrrZ is_pos_stepZ pos_for_rangeZ neg_for_rangerZthenZ otherwiserrrfor_range_slice_generic"s rCc csp|dks t|sfVnT|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. CFFcSs|dddS)Nrr)xrrrTszloop_nest..cSs|S)Nr)rrrrrVsN)rG _loop_nestr)r shaperorderZ_swapindicesrrr loop_nest@s  rccsht||d|dL}t|dkrPt||dd|}|jf|VWdQRXn |jfVWdQRXdS)Nr)rr)rrrrU)r rrlooprrrrr\s  rcCsTt|}|dkr|dj}tj||tj}x"t|D]\}}|j|||}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 rrrrr)r rrr!aryrrrrr pack_arrayfs rcs0|dkrtjj}fddt|D}|S)zH Unpack an array or structure of values, return a Python tuple. Ncsg|]}j|qSr) extract_value)rr)r tuprrr|sz unpack_tuple..)rr elementsrange)r rrvalsr)r rr unpack_tupleus    rc Cs>t||j|jd}t||j|jd}t||j|||j||dS)N)r)r#rstrideslayoutinds wraparound)rrndimrget_item_pointer2r#r)r ZarytyrrrZshapesrrrrget_item_pointers  rcs|rZg}xTt||D]@\}} jd||jd} j| |} j| | |} |j| qWn|}|stj|tdgS|dj} |dkrg}|dkrxtt |D]<}| d}x$||ddD]}j ||}qW|j|qWn`|dkr.)ziprr rZselectryr|rxrrr Exception functoolsreduce pointer_add)r r#rrrrrrindZdimlennegativewrappedZselectedrZstepsrZlastjlocrZtmprgZdimoffsoffsetr)r rrsF     rcCs\|jd}t|jtjtjfr*|||}n.t|jtjrH|j|||}ntd|jf|S)Nrzunexpected value type %s)r r@rZ FloatTypeZ DoubleTyperrrA)r rZfpredZicondZnullvalZisnullrrr_scalar_pred_against_zeros  rcCst||tj|jddS)zK Return a predicate representing whether *value* is equal to zero. z==)rrpartial fcmp_ordered)r rrrris_scalar_zerosrcCst||tj|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)r rrrris_not_scalar_zerosrcCst||tj|jddS)z] Return a predicate representing whether *value* is equal to either zero or NaN. z==)rrrr)r rrrris_scalar_zero_or_nansrcCst||tj|jddS)z: Is *value* negative? Assumes *value* is signed. r)rrrr)r rrrr is_scalar_negsrc CsL|jt||dd.|d}|ddp,d}|jj|||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)rOr rZ exc_tupleexcexc_argsrrr guard_nullsrc CsZt|jtjst|j|r"|fnf}|jt||dd|jj|t |WdQRXdS)zG Guard against *pointer* being NULL (and raise a MemoryError). F)rN) r@r r PointerTyperGrrrr MemoryError)rOr Zpointermsgrrrrguard_memory_errorsrc cs*|jt|||d dVWdQRXdS)z> Execute the given block if the scalar value is zero. )rN)rr)r rrrrrif_zerosrcCs t|tjS)z7 Whether the LLVM type *typ* is a struct type. )r@rr)ZltyprrrrF srFcCs0t||d|}t|jj s t|j||jS)Nr)rYrFr rIrGrurJ)r recordrtypZpvalrrrget_record_membersrcCs|jd||jdS)Nrr)rr )r rVrrr is_neg_intsrcOst||f|ddi|S)z8 Same as *gep*, but add the `inbounds` keyword. r{T)r|)r rgrkwsrrrrYsrYc Osj|jdd}|jdd}| s"tg}x0|D](}t|tjrFt|}n|}|j|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. rr}r{F)rr{)r4rGr@rrrxryr|) r rgrrrr{idxrrrrrr|#s      r|cCs>|j|t}t|tjr t|}|j||}|j||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. )Zptrtointrr@rrrZinttoptrr )r rgrZ return_typeZintptrrrrr6s    rcCsd|j}d|j}|jjdt|jf}|j|t}t|trBt|}|j ||||t dt dgdS)z= Fill *size* bytes starting from *ptr* with *value*. zllvm.memset.p0i8.i%dz llvm.memsetrN) r widthrdeclare_intrinsic voidptr_trur@intint8_tcallrxbool_t)r rgr~rZsizetymemsetrrrrrEs   rinternalcCs>t|tjr|}n|j}|j|j|d}||_d|_||_|S)zO Get or create a (LLVM module-)global constant with *name* or *value*. )rT) r@rZModulerZadd_global_variabler linkageglobal_constantZ initializer)Zbuilder_or_modulerrrrr#rrrrRs rc Cs|dks t|j|}|jd}t||j}|jt||n\}}||j||}|j||WdQRX|2|j||}|j||}|j|j|||WdQRXWdQRX|j |}|j||j ||} || 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) rGr rSrrZsdivrKrsubrer) r rVZdivisorrZquotZif_negZif_posZquot_valZ val_plus_oneZrem_valrrrdivmod_by_constantas       ( rcCs&|jd}|j||||j||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)r rZbbtrueZbbcontrrrcbranch_or_continues  rc Csb|j|jkstt|||jd8}|j||jg}|j||jg}|j|j||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 rGrr|rUrKre)r r8r9rrZout_ptrZin_ptrrrrmemcpys rc Csz|j}t|tjrtj||}|jj|tt|g}tjtj d|}t } |j ||j |t|j |t|j |||| gdS)Nr )r r@rrrrrrrr false_bitrrur) r Z func_namer8r9ritemsizealignZsize_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 )r r8r9rrr 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 )r r8r9rrr rrr raw_memmovesr c CsX|j||}|j|d}|j|d}|j||}|j|d}|j||j|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_) r ar cpZprodZprod_ovfrr-Zovfrrrmuladd_with_overflows     rc Gst|tst|j}t}t|djd}t|d|}tj t |gdd}y|j d}Wn$t k rztj ||dd}YnX|j||} |j|| 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)Zvar_argprintf)r)r@r+rGrrr"encoderr FunctionTyperxZ get_globalKeyErrorZFunctionrurlist) r rBargsmodZcstringZ fmt_bytesZ global_fmtrrZptr_fmtrrrrs   rcCs|jdjdS)zw Normalize the given string to latin1 compatible encoding that is suitable for use in LLVM IR. utf8latin1)rdecode)textrrrnormalize_ir_textsrcCs|S)zI No-op for python2. Assume there won't be unicode names. r)rrrrrsc Csd}|j|t}t|d||tjd}|j||j}t||p}|j|j t|}|j d|td}|j |t|dWdQRX|j ||j g}|j |} 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)ZzextrrrrrurJrZuremrUr rr|re) r rgnbytesZbytes_per_lineZbyte_trZdiv_byZ do_new_linerrVrrrhexdumps     r#)N)r)Nr}F)r})rUr)NN)NT)r)N)N)F)F)N)F)N)r)r)r)XroZ __future__rrr collections contextlibrrZllvmliterr}rrrrrxZ MACHINE_BITSrrJrZtrue_bitrZ true_byteZ false_byterrr"r&r0r<objectr=r(r)rsrSrrrrrrrrrr namedtuplerrrrrrrrrrrrrrZis_trueZis_falserrrrZ guard_zerorFrrrYr|rrrrrrr r r rrZPY3rr#rrrrs           l     + 9    2