U |e@sddlZddlZddlmZmZmZddddddd Zejfd d Zejfd d Z ejfddZ ejfddZ ddZ ddZ ddZddZejfddZddZGdddeZdS) N) instructionstypesvaluesgtlteqnegele)><==!=z>=z<=csfdd}|S)Ncst|dfdd }|S)Ncs&|j|j|g||}|||SNblocktype_insert)selfargnameflagsinstrclsopnamerP/var/www/website-v5/atlas_env/lib/python3.8/site-packages/llvmlite/ir/builder.pywrappeds z$_unop..wrap..wrapped)rr functoolswrapsfnrrrrwrapsz_unop..wraprrrr%rrr_unops r'csfdd}|S)Ncst|dfdd }|S)NrrcsH|j|jkr td|j|jf|j|j||f||}|||S)N,Operands must be the same type, got (%s, %s))r ValueErrorrr)rlhsrhsrrrrrrrs   z%_binop..wrap..wrapped)rrr r#rrrr%sz_binop..wraprr&rrr_binops r,csfdd}|S)Ncst|dfdd }|S)Nrc s|j|jkr td|j|jf|j}t|tjs@td|ftd}|j}tt||g||g}| df|g|}|j |||g|d} | S)Nr( expected an integer type, got %szllvm.%s.with.overflowr) rr) isinstancerIntType TypeErrormodule FunctionTypeLiteralStructTypedeclare_intrinsiccall) rr*r+rtyZbool_tymodfntyr$retrrrr/s$     z3_binop_with_overflow..wrap..wrapped)rr r#r<rrr%.sz"_binop_with_overflow..wraprr&rr<r_binop_with_overflow-s r=csfdd}|S)Ncst|dfdd }|S)Nrcs$|j|j|g|}|||Srr)roperandrrrrrrHs z%_uniop..wrap..wrapped)rr r#rrrr%Gsz_uniop..wraprr&rrr_uniopFs r?csfdd}|S)Ncst|dfdd }|S)Nrcs>t|jtjstd|j|j|jg}|||g|S)Nr-)r0rrr1r2r3r6r7rr>rr$r<rrrUsz3_uniop_intrinsic_int..wrap..wrapped)rr r#r<rrr%Tsz"_uniop_intrinsic_int..wraprrr%rr<r_uniop_intrinsic_intSs rBcsfdd}|S)Ncst|dfdd }|S)NrcsDt|jtjtjfs"td|j|j|jg}|||g|S)Nexpected a float type, got %s) r0rr FloatType DoubleTyper2r3r6r7r@r<rrres z5_uniop_intrinsic_float..wrap..wrapped)rr r#r<rrr%dsz$_uniop_intrinsic_float..wraprrArr<r_uniop_intrinsic_floatcs rFcsfdd}|S)Ncst|dfdd }|S)Nrcslt|jtjstd|jt|jtjr6|jjdksDtd|j|j|j|jg}||||g|S)Nr-r.zexpected an i1 type, got %s) r0rrr1r2widthr3r6r7)rr>flagrr$r<rrrts  z9_uniop_intrinsic_with_flag..wrap..wrapped)rr r#r<rrr%ss z(_uniop_intrinsic_with_flag..wraprrArr<r_uniop_intrinsic_with_flagrs rIcsfdd}|S)Ncst|dfdd }|S)Nrcs|j|jks|j|jkr2td|j|j|jfn&t|jtjtjtjfsXtd|j|j|j|j|jg}| ||||g|S)Nz-expected types to be the same, got %s, %s, %sz'expected an floating point type, got %s) rr2r0rHalfTyperDrEr3r6r7)rabcrr$r<rrrs&z/_triop_intrinsic..wrap..wrapped)rr r#r<rrr%sz_triop_intrinsic..wraprrArr<r_triop_intrinsics rNcsfdd}|S)Ncst|dfdd }|S)Nrcs.|j|kr|S|j|||}|||Sr)rrr)rvaltyprrrrrrs   z&_castop..wrap..wrapped)rr r#rrrr%sz_castop..wraprr&rrr_castops rQcCs4t|dkr(d}d|d|d|gS||SdS)zReturns (label + suffix) or a truncated version if it's too long. Parameters ---------- label : str Label name suffix : str Label suffix 2rNz..)lenjoin)labelsuffixZnheadrrr _label_suffixs rXc@seZdZdddZeddZeZeddZedd Zd d Z d d Z ddZ ddZ dddZ ddZejddZejddZejddZejdddZejddd Zd!d"Zd#d$Zed%dd&d'Zed(dd)d*Zed+dd,d-Zed.dd/d0Zed1dd2d3Zed4dd5d6Zed7dd8d9Zed:dd;d<Z ed=dd>d?Z!ed@d dAdBZ"edCd dDdEZ#edFd dGdHZ$edId dJdKZ%edLd dMdNZ&edOddPdQZ'edRddSdTZ(edUddVdWZ)edXddYdZZ*e+d[dd\d]Z,e+d^dd_d`Z-e+daddbdcZ.e+ddddedfZ/e+dgddhdiZ0e+djddkdlZ1ddmdnZ2ddodpZ3e4dqddsdtZ5dudvZ6ddwdxZ7ddydzZ8dd{d|Z9dd}d~Z:dddZ;eeddބZdd?ddZeddZfd@ddZgehdddZiehdddZjehdddZkeldddZmeldddZneodddZpdAddZqerdddZsdS(B IRBuilderNcCs$||_|rt|jnd|_d|_dS)Nr)_blockrTr_anchordebug_metadatarrrrr__init__szIRBuilder.__init__cCs|jS)z* The current basic block. )rZrrrrrszIRBuilder.blockcCs|jjS)z' The current function. )rparentr_rrrfunctionszIRBuilder.functioncCs |jjjS)z% The current module. )rr`r3r_rrrr3szIRBuilder.modulecCs|j|_|jj||_dS)z Position immediately before the given instruction. The current block is also changed to the instruction's basic block. Nr`rZrindexr[rrrrrposition_beforeszIRBuilder.position_beforecCs |j|_|jj|d|_dS)z Position immediately after the given instruction. The current block is also changed to the instruction's basic block. r.Nrbrdrrrposition_afterszIRBuilder.position_aftercCs||_d|_dS)z= Position at the start of the basic *block*. rN)rZr[r]rrrposition_at_startszIRBuilder.position_at_startcCs||_t|j|_dS)z; Position at the end of the basic *block*. N)rZrTrr[r]rrrposition_at_endszIRBuilder.position_at_endrcCs |j|S)z Append a basic block, with the given optional *name*, to the current function. The current block is not changed. The new block is returned. )raappend_basic_block)rrrrrriszIRBuilder.append_basic_blockcCsH|jj|}|jj|=|jj|kr,d|j_|j|krD|jd8_dS)zRemove the given instruction.Nr.)rZrrc terminatorr[)rridxrrrremoves    zIRBuilder.removec csF|j}|j}|dk r ||n ||z dVW5||XdS)z A context manager which temporarily positions the builder at the end of basic block *bb* (but before any terminator). N) basic_blockrjrerh)rrZ old_blocktermrrr goto_blocks   zIRBuilder.goto_blockc cs$||jj dVW5QRXdS)z} A context manager which temporarily positions the builder at the end of the function's entry block. N)roraentry_basic_blockr_rrrgoto_entry_blockszIRBuilder.goto_entry_blockccs*|||V|jjdkr&||dSr)rhrmrjbranch)rZbbenterZbbexitrrr_branch_helper"s  zIRBuilder._branch_helperc cs|j}|jt|jdd}|jt|jdd}||||}|dk r^||rTddgnddg||| |VW5QRX||dS)a A context manager which sets up a conditional basic block based on the given predicate (a i1 value). If the conditional block is not explicitly terminated, a branch will be added to the next block. If *likely* is given, its boolean value indicates whether the predicate is likely to be true or not, and metadata is issued for LLVM's optimizers to account for that. .ifr/.endifNcr.rmrirXrcbranchZ set_weightsrsrh)rpredlikelybbbbifbbendbrrrrif_then)s zIRBuilder.if_thenc cs|j}|jt|jdd}|jt|jdd}|jt|jdd}||||}|dk rr||rhddgnddg|||}|||} || fV||dS)a@ A context manager which sets up two conditional basic blocks based on the given predicate (a i1 value). A tuple of context managers is yield'ed. Each context manager acts as a if_then() block. *likely* has the same meaning as in if_then(). Typical use:: with builder.if_else(pred) as (then, otherwise): with then: # emit instructions for when the predicate is true with otherwise: # emit instructions for when the predicate is false rtr/z.elseruNrvr.rw) rryrzr{r|Zbbelser}r~then otherwiserrrif_else@s   zIRBuilder.if_elsecCsD|jdk r d|jkr |j|jd<|jj|j||jd7_dS)NZdbgr.)r\metadatarZrinsertr[rdrrrr_s zIRBuilder._insertcCs"|jjr t||||j_|Sr)r is_terminatedAssertionErrorrrj)rrnrrr_set_terminatores  zIRBuilder._set_terminatorshlcCsdS)zC Left integer shift: name = lhs << rhs Nrrr*r+rrrrrosz IRBuilder.shllshrcCsdS)zW Logical (unsigned) right integer shift: name = lhs >> rhs NrrrrrrvszIRBuilder.lshrashrcCsdS)zX Arithmetic (signed) right integer shift: name = lhs >> rhs Nrrrrrr}szIRBuilder.ashraddcCsdS)z@ Integer addition: name = lhs + rhs Nrrrrrrsz IRBuilder.addfaddcCsdS)zG Floating-point addition: name = lhs + rhs NrrrrrrszIRBuilder.faddsubcCsdS)zC Integer subtraction: name = lhs - rhs Nrrrrrrsz IRBuilder.subfsubcCsdS)zJ Floating-point subtraction: name = lhs - rhs NrrrrrrszIRBuilder.fsubmulcCsdS)zF Integer multiplication: name = lhs * rhs Nrrrrrrsz IRBuilder.mulfmulcCsdS)zM Floating-point multiplication: name = lhs * rhs NrrrrrrszIRBuilder.fmuludivcCsdS)zI Unsigned integer division: name = lhs / rhs NrrrrrrszIRBuilder.udivsdivcCsdS)zG Signed integer division: name = lhs / rhs NrrrrrrszIRBuilder.sdivfdivcCsdS)zG Floating-point division: name = lhs / rhs NrrrrrrszIRBuilder.fdivuremcCsdS)zJ Unsigned integer remainder: name = lhs % rhs NrrrrrrszIRBuilder.uremsremcCsdS)zH Signed integer remainder: name = lhs % rhs NrrrrrrszIRBuilder.sremfremcCsdS)zH Floating-point remainder: name = lhs % rhs NrrrrrrszIRBuilder.fremorcCsdS)zB Bitwise integer OR: name = lhs | rhs Nrrrrror_sz IRBuilder.or_andcCsdS)zC Bitwise integer AND: name = lhs & rhs Nrrrrrand_szIRBuilder.and_xorcCsdS)zC Bitwise integer XOR: name = lhs ^ rhs Nrrrrrrsz IRBuilder.xorZsaddcCsdS)zn Signed integer addition with overflow: name = {result, overflow bit} = lhs + rhs Nrrrrrsadd_with_overflowszIRBuilder.sadd_with_overflowZsmulcCsdS)zt Signed integer multiplication with overflow: name = {result, overflow bit} = lhs * rhs Nrrrrrsmul_with_overflowszIRBuilder.smul_with_overflowZssubcCsdS)zq Signed integer subtraction with overflow: name = {result, overflow bit} = lhs - rhs Nrrrrrssub_with_overflowszIRBuilder.ssub_with_overflowZuaddcCsdS)zp Unsigned integer addition with overflow: name = {result, overflow bit} = lhs + rhs Nrrrrruadd_with_overflowszIRBuilder.uadd_with_overflowZumulcCsdS)zv Unsigned integer multiplication with overflow: name = {result, overflow bit} = lhs * rhs Nrrrrrumul_with_overflow szIRBuilder.umul_with_overflowZusubcCsdS)zs Unsigned integer subtraction with overflow: name = {result, overflow bit} = lhs - rhs Nrrrrrusub_with_overflowszIRBuilder.usub_with_overflowcCsDt|jtjr&t|jd|jj}nt|jd}|j|||dS)zG Bitwise integer complement: name = ~value )rr/)r0rr VectorTyperConstantcountr)rvaluerr+rrrnot_szIRBuilder.not_cCs|jt|jd||dS)z= Integer negative: name = -value rr/)rrrr)rrrrrrneg&sz IRBuilder.negfnegrcCsdS)zB Floating-point negative: name = -arg Nr)rrrrrrrr-szIRBuilder.fnegcCsdz t|}Wn"tk r.td|fYnX|dkr@||}tj|j||||d}|||S)Nzinvalid comparison %r for icmp)r rr/)_CMP_MAPKeyErrorr)rZ ICMPInstrrr)rprefixcmpopr*r+roprrrr_icmp8s  zIRBuilder._icmpcCs|d||||S)z Signed integer comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=' srrrr*r+rrrr icmp_signedCszIRBuilder.icmp_signedcCs|d||||S)z Unsigned integer (or pointer) comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=' urrrrr icmp_unsignedLszIRBuilder.icmp_unsignedcCs@|tkrdt|}n|}tj|j|||||d}|||S)z Floating-point ordered comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' orrrrZ FCMPInstrrrrrr*r+rrrrrrr fcmp_orderedUs zIRBuilder.fcmp_orderedcCs@|tkrdt|}n|}tj|j|||||d}|||S)z Floating-point unordered comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' rrrrrrrfcmp_unorderedes zIRBuilder.fcmp_unorderedcCs&tj|j|||||d}|||S)zN Ternary select operator: name = cond ? lhs : rhs r)rZ SelectInstrrr)rcondr*r+rrrrrrselectus  zIRBuilder.selecttrunccCsdS)z_ Truncating integer downcast to a smaller type: name = (typ) value NrrrrPrrrrrszIRBuilder.trunczextcCsdS)z` Zero-extending integer upcast to a larger type: name = (typ) value NrrrrrrszIRBuilder.zextsextcCsdS)z` Sign-extending integer upcast to a larger type: name = (typ) value NrrrrrrszIRBuilder.sextfptrunccCsdS)z` Floating-point downcast to a less precise type: name = (typ) value NrrrrrrszIRBuilder.fptruncfpextcCsdS)z^ Floating-point upcast to a more precise type: name = (typ) value NrrrrrrszIRBuilder.fpextbitcastcCsdS)zZ Pointer cast to a different pointer type: name = (typ) value NrrrrrrszIRBuilder.bitcast addrspacecastcCsdS)z[ Pointer cast to a different address space: name = (typ) value NrrrrrrszIRBuilder.addrspacecastfptouicCsdS)z\ Convert floating-point to unsigned integer: name = (typ) value NrrrrrrszIRBuilder.fptouiuitofpcCsdS)z\ Convert unsigned integer to floating-point: name = (typ) value NrrrrrrszIRBuilder.uitofpfptosicCsdS)zZ Convert floating-point to signed integer: name = (typ) value NrrrrrrszIRBuilder.fptosisitofpcCsdS)zZ Convert signed integer to floating-point: name = (typ) value NrrrrrrszIRBuilder.sitofpptrtointcCsdS)zI Cast pointer to integer: name = (typ) value NrrrrrrszIRBuilder.ptrtointinttoptrcCsdS)zI Cast integer to pointer: name = (typ) value NrrrrrrszIRBuilder.inttoptrcCsb|dkr n8t|tjtjfr0t|jtjsBtnttd|}t |j |||}| ||S)zl Stack-allocate a slot for *size* elements of the given type. (default one element) N ) r0rValuerrrr1rrZ AllocaInstrrr)rrPsizerZalrrrallocas zIRBuilder.allocacCsLt|jtjs(d}t||jt|ft|j||}||_ | ||Szf Load value from pointer, with optional guaranteed alignment: name = *ptr z5cannot load from value of type %s (%r): not a pointer) r0rr PointerTyper2strrZ LoadInstrralignr)rptrrrmsgldrrrloads zIRBuilder.loadcCsnt|jtjs(d}t||jt|f|jj|jkrJtd|j|jft|j ||}||_ | ||Sze Store value to pointer, with optional guaranteed alignment: *ptr = name z4cannot store to value of type %s (%r): not a pointerz(cannot store %s to %s: mismatching types) r0rrrr2rpointeerZ StoreInstrrrr)rrrrrstrrrstores  zIRBuilder.storecCsJt|jtjs(d}t||jt|ft|j||||}| ||Sr) r0rrrr2rrZLoadAtomicInstrrr)rrorderingrrrrrrr load_atomics zIRBuilder.load_atomiccCslt|jtjs(d}t||jt|f|jj|jkrJtd|j|jft|j ||||}| ||Sr) r0rrrr2rrrZStoreAtomicInstrrr)rrrrrrrrrr store_atomics   zIRBuilder.store_atomiccCs t|jd||}|||S)zF Create a switch-case with a single *default* target. switch)rZ SwitchInstrrr)rrdefaultZswtrrrr2s zIRBuilder.switchcCs t|jd|g}|||S)z3 Unconditional branch to *target*. r~rBranchrr)rtargetr~rrrrr:s zIRBuilder.branchcCs$t|jd|||g}|||S)zV Conditional branch to *truebr* if *cond* is true, else to *falsebr*. r~)rZConditionalBranchrr)rrtruebrfalsebrr~rrrrxBs   zIRBuilder.cbranchcCst|jd|}|||S)z3 Indirect branch to target *addr*. Z indirectbr)rZIndirectBranchrr)raddrr~rrrbranch_indirectKs zIRBuilder.branch_indirectcCs|t|jdS)z7 Return from function without a value. zret voidrrZRetrr_rrrret_voidSs zIRBuilder.ret_voidcCs|t|jd|S)z> Return from function with the given *value*. r;r)rrrrrr;Zsz IRBuilder.retcCs t|jd|g}|||S)z0 Resume an in-flight exception. resumer)r landingpadr~rrrras zIRBuilder.resumeFc Cs,tj|j||||||||d } || | S)zP Call function *fn* with *args*: name = fn(args...) )rcconvtailfastmathattrs arg_attrs)rZ CallInstrrr) rr$argsrrrrrrinstrrrr7ks zIRBuilder.callcCst||||}||||S)z# Inline assembler. )rZ InlineAsmr7)rftypeasm constraintrZ side_effectrrrrrwsz IRBuilder.asmcCs$t|g}||dd|gd|S)zo Load a register value into an LLVM value. Example: v = load_reg(IntType(32), "eax") rz={%s}F)rr4r)rreg_typereg_namerrrrrload_reg~s zIRBuilder.load_regcCs,tt|g}||dd||gd|S)z Store an LLVM value inside a register Example: store_reg(Constant(IntType(32), 0xAAAAAAAA), IntType(32), "eax") rz{%s}T)rr4VoidTyper)rrrrrrrrr store_regszIRBuilder.store_regc Cs.tj|j||||||||| d } || | S)N)rrrrr)rZ InvokeInstrrr) rr$rZ normal_toZ unwind_torrrrrrrrrinvokes zIRBuilder.invokecCs$tj|j||||d}|||S)zo Compute effective address (getelementptr): name = getelementptr ptr, )inboundsr)rZGEPInstrrr)rrindicesrrrrrrgeps   z IRBuilder.gepcCs"tj|j|||d}|||S)z4 Returns the value at position idx. r/)rZExtractElementrr)rvectorrkrrrrrextract_elements zIRBuilder.extract_elementcCs$tj|j||||d}|||S)z Returns vector with vector[idx] replaced by value. The result is undefined if the idx is larger or equal the vector length. r/)rZ InsertElementrr)rrrrkrrrrrinsert_elements  zIRBuilder.insert_elementcCs$tj|j||||d}|||S)a Constructs a permutation of elements from *vector1* and *vector2*. Returns a new vector in the same length of *mask*. * *vector1* and *vector2* must have the same element type. * *mask* must be a constant vector of integer types. r/)rZ ShuffleVectorrr)rZvector1Zvector2maskrrrrrshuffle_vectors  zIRBuilder.shuffle_vectorcCs6t|ttfs|g}tj|j|||d}|||S)z= Extract member number *idx* from aggregate. r/)r0tuplelistrZ ExtractValuerr)raggrkrrrrr extract_values  zIRBuilder.extract_valuecCs8t|ttfs|g}tj|j||||d}|||S)zI Insert *value* into member number *idx* from aggregate. r/)r0rrrZ InsertValuerr)rrrrkrrrrr insert_values  zIRBuilder.insert_valuecCs"tj|j|||d}|||S)Nr)rZPhiInstrrr)rrPrrrrrrphis z IRBuilder.phicCst|j}|||Sr)r Unreachablerr)rrrrr unreachables  zIRBuilder.unreachablecCs&tj|j|||||d}|||S)Nr/)rZ AtomicRMWrr)rrrrOrrrrrr atomic_rmws zIRBuilder.atomic_rmwc Cs8|dkr |n|}tj|j||||||d}|||S)a8 Atomic compared-and-set: atomic { old = *ptr success = (old == cmp) if (success) *ptr = val } name = { old, success } If failordering is `None`, the value of `ordering` is used. Nr/)rZCmpXchgrr)rrcmprOrZ failorderingrrrrrcmpxchgs  zIRBuilder.cmpxchgcCs t|j|||}|||Sr)rZLandingPadInstrrr)rrPrcleanuprrrrrs zIRBuilder.landingpadcCs|jd}|||gS)z? Optimizer hint: assume *cond* is always true. z llvm.assume)r3r6r7)rrr$rrrassumes zIRBuilder.assumecCs"tj|j|||d}|||S)z Add a memory barrier, preventing certain reorderings of load and/or store accesses with respect to other processors and devices. r/)rZFencerr)rrZ targetscoperrrrrfences zIRBuilder.fencez llvm.bswapcCsdS)zv Used to byte swap integer values with an even number of bytes (positive multiple of 16 bits) NrrrrrrbswapszIRBuilder.bswapzllvm.bitreversecCsdS)zp Reverse the bitpattern of an integer value; for example 0b10110110 becomes 0b01101101. Nrrrrr bitreverseszIRBuilder.bitreversez llvm.ctpopcCsdS)z; Counts the number of bits set in a value. Nrrrrrctpop&szIRBuilder.ctpopz llvm.ctlzcCsdS)z Counts leading zero bits in *value*. Boolean *flag* indicates whether the result is defined for ``0``. NrrrrHrrrctlz,szIRBuilder.ctlzz llvm.cttzcCsdS)z Counts trailing zero bits in *value*. Boolean *flag* indicates whether the result is defined for ``0``. Nrrrrrcttz3szIRBuilder.cttzzllvm.fmacCsdS)z; Perform the fused multiply-add operation. Nr)rrKrLrMrrrfma:sz IRBuilder.fmacCsv|s tdt|tjtjfs*td|t|jtjrD|jjdksRtd|jd}|j ||g}| ||g|S)z: Convert from an i16 to the given FP type zexpected a float return typerCzexpected an i16 type, got %szllvm.convert.from.fp16) r2r0rrDrErr1rGr3r6r7)rrKtorrr$rrrconvert_from_fp16@s zIRBuilder.convert_from_fp16zllvm.convert.to.fp16cCsdS)z7 Convert the given FP number to an i16 Nr)rrKrrrconvert_to_fp16OszIRBuilder.convert_to_fp16)N)r)N)N)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)r)rr)r)r)rr)rr)rr)r)r)r)r)r)r)r)r)r)r)r)r)r)Nr)rN)N)r)rNFrrN)r)r)r)rNrrN)Fr)r)r)r)r)r)rr)r)Nr)rF)Nr)Nr)t__name__ __module__ __qualname__r^propertyrrmrar3rerfrgrhrirl contextlibcontextmanagerrorqrsrrrrr,rrrrrrrrrrrrrrrrrrr=rrrrrrrrr'rrrrrrrrQrrrrrrrrrrrrrrrrrrrrrrxrrr;rr7rrrrrrrrrr r r r rrrrrBrrrrIrrrNrrrFrrrrrrYsF                                       rY)r#r! llvmlite.irrrrr Instructionr'r,r=r?rBrFrIrNZ CastInstrrQrXobjectrYrrrrs(