o
    Fôj|„  ã                   @   s¸   d dl Z d dlZd dlmZmZmZ ddddddd	œZejfd
d„Zejfdd„Z	ejfdd„Z
ejfdd„Zdd„ Zdd„ Zdd„ Zdd„ Zejfdd„Zdd„ ZG dd„ deƒZdS ) é    N)ÚinstructionsÚtypesÚvaluesÚgtÚltÚeqÚneÚgeÚle)ú>ú<ú==ú!=z>=z<=c                    ó   ‡ ‡fdd„}|S )Nc                    ó   t  | ¡d‡ ‡fdd„	ƒ}|S )NÚ © c                    s&   ˆ | j |jˆ|g||ƒ}|  |¡ |S ©N©ÚblockÚtypeÚ_insert)ÚselfÚargÚnameÚflagsÚinstr©ÚclsÚopnamer   úd/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/llvmlite/ir/builder.pyÚwrapped   s   
z$_unop.<locals>.wrap.<locals>.wrapped©r   r   ©Ú	functoolsÚwraps©Úfnr!   r   r   r    Úwrap   ó   z_unop.<locals>.wrapr   ©r   r   r(   r   r   r    Ú_unop   ó   	r+   c                    r   )Nc                    r   )Nr   r   c                    sH   |j |j krtd|j |j f ƒ‚ˆ | j|j ˆ||f||ƒ}|  |¡ |S )Nú,Operands must be the same type, got (%s, %s))r   Ú
ValueErrorr   r   )r   ÚlhsÚrhsr   r   r   r   r   r    r!      s   
ÿ
z%_binop.<locals>.wrap.<locals>.wrappedr"   r#   r&   r   r   r    r(      s   z_binop.<locals>.wrapr   r*   r   r   r    Ú_binop   s   r1   c                    s   ‡ fdd„}|S )Nc                    ó   t  | ¡d‡ fdd„	ƒ}|S )Nr   c           
         s˜   |j |j krtd|j |j f ƒ‚|j }t|tjƒs td|f ƒ‚t d¡}| j}t t ||g¡||g¡}| 	dˆ f |g|¡}| j
|||g|d�}	|	S )Nr-   ú expected an integer type, got %sé   zllvm.%s.with.overflow©r   )r   r.   Ú
isinstancer   ÚIntTypeÚ	TypeErrorÚmoduleÚFunctionTypeÚLiteralStructTypeÚdeclare_intrinsicÚcall)
r   r/   r0   r   ÚtyZbool_tyÚmodÚfntyr'   Úret©r   r   r    r!   /   s"   
ÿ
ÿÿz3_binop_with_overflow.<locals>.wrap.<locals>.wrapped©r   r#   r&   rB   r   r    r(   .   s   z"_binop_with_overflow.<locals>.wrapr   r*   r   rB   r    Ú_binop_with_overflow-   s   rD   c                    r   )Nc                    ó   t  | ¡d‡ ‡fdd„	ƒ}|S )Nr   c                    s$   ˆ | j |jˆ|g|ƒ}|  |¡ |S r   r   )r   Úoperandr   r   r   r   r    r!   H   s   
z%_uniop.<locals>.wrap.<locals>.wrappedrC   r#   r&   r   r   r    r(   G   r)   z_uniop.<locals>.wrapr   r*   r   r   r    Ú_uniopF   r,   rG   c                    ó   ‡ fdd„}|S )Nc                    r2   )Nr   c                    s>   t |jtjƒstd|j ƒ‚| j ˆ |jg¡}|  ||g|¡S )Nr3   )r6   r   r   r7   r8   r9   r<   r=   ©r   rF   r   r'   rB   r   r    r!   U   s   ÿÿz3_uniop_intrinsic_int.<locals>.wrap.<locals>.wrappedrC   r#   r&   rB   r   r    r(   T   s   z"_uniop_intrinsic_int.<locals>.wrapr   ©r   r(   r   rB   r    Ú_uniop_intrinsic_intS   s   rK   c                    rH   )Nc                    r2   )Nr   c                    sD   t |jtjtjfƒstd|j ƒ‚| j ˆ |jg¡}|  ||g|¡S )Núexpected a float type, got %s)	r6   r   r   Ú	FloatTypeÚ
DoubleTyper8   r9   r<   r=   rI   rB   r   r    r!   e   s   ÿz5_uniop_intrinsic_float.<locals>.wrap.<locals>.wrappedrC   r#   r&   rB   r   r    r(   d   s   z$_uniop_intrinsic_float.<locals>.wrapr   rJ   r   rB   r    Ú_uniop_intrinsic_floatc   s   rO   c                    rH   )Nc                    r2   )Nr   c                    sl   t |jtjƒstd|j ƒ‚t |jtjƒr|jjdks"td|j ƒ‚| j ˆ |j|jg¡}|  |||g|¡S )Nr3   r4   zexpected an i1 type, got %s)	r6   r   r   r7   r8   Úwidthr9   r<   r=   )r   rF   Úflagr   r'   rB   r   r    r!   t   s   ÿÿÿz9_uniop_intrinsic_with_flag.<locals>.wrap.<locals>.wrappedrC   r#   r&   rB   r   r    r(   s   s   z(_uniop_intrinsic_with_flag.<locals>.wrapr   rJ   r   rB   r    Ú_uniop_intrinsic_with_flagr   s   rR   c                    rH   )Nc                    r2   )Nr   c                    s„   |j |j ks|j |j krtd|j |j |j f ƒ‚t|j tjtjtjfƒs+td|j  ƒ‚| j ˆ |j |j |j g¡}|  	||||g|¡S )Nz-expected types to be the same, got %s, %s, %sz'expected an floating point type, got %s)
r   r8   r6   r   ÚHalfTyperM   rN   r9   r<   r=   )r   ÚaÚbÚcr   r'   rB   r   r    r!   ˆ   s&   ýÿþÿÿz/_triop_intrinsic.<locals>.wrap.<locals>.wrappedrC   r#   r&   rB   r   r    r(   ‡   s   z_triop_intrinsic.<locals>.wrapr   rJ   r   rB   r    Ú_triop_intrinsic†   s   rW   c                    r   )Nc                    rE   )Nr   c                    s.   |j |kr|S ˆ | jˆ|||ƒ}|  |¡ |S r   )r   r   r   )r   ÚvalÚtypr   r   r   r   r    r!       s
   

z&_castop.<locals>.wrap.<locals>.wrappedrC   r#   r&   r   r   r    r(   Ÿ   s   z_castop.<locals>.wrapr   r*   r   r   r    Ú_castopž   s   rZ   c                 C   s0   t | ƒdkrd}d | d|… d|g¡S | | S )z­Returns (label + suffix) or a truncated version if it's too long.
    Parameters
    ----------
    label : str
        Label name
    suffix : str
        Label suffix
    é2   é   r   Nz..)ÚlenÚjoin)ÚlabelÚsuffixÚnheadr   r   r    Ú_label_suffix­   s   	rb   c                   @   s‚  e Zd Zdþdd„Zedd„ ƒZeZedd„ ƒZedd	„ ƒZd
d„ Z	dd„ Z
dd„ Zdd„ Zdÿdd„Zdd„ Zejdd„ ƒZejdd„ ƒZejdd„ ƒZejdþdd„ƒZejdþdd „ƒZd!d"„ Zd#d$„ Zed%ƒdÿd&d'„ƒZed(ƒdÿd)d*„ƒZed+ƒdÿd,d-„ƒZed.ƒdÿd/d0„ƒZed1ƒdÿd2d3„ƒZed4ƒdÿd5d6„ƒZed7ƒdÿd8d9„ƒZed:ƒdÿd;d<„ƒZ ed=ƒdÿd>d?„ƒZ!ed@ƒdÿdAdB„ƒZ"edCƒdÿdDdE„ƒZ#edFƒdÿdGdH„ƒZ$edIƒdÿdJdK„ƒZ%edLƒdÿdMdN„ƒZ&edOƒdÿdPdQ„ƒZ'edRƒdÿdSdT„ƒZ(edUƒdÿdVdW„ƒZ)edXƒdÿdYdZ„ƒZ*e+d[ƒdÿd\d]„ƒZ,e+d^ƒdÿd_d`„ƒZ-e+daƒdÿdbdc„ƒZ.e+ddƒdÿdedf„ƒZ/e+dgƒdÿdhdi„ƒZ0e+djƒdÿdkdl„ƒZ1dÿdmdn„Z2dÿdodp„Z3e4dqƒ�d dsdt„ƒZ5dudv„ Z6dÿdwdx„Z7dÿdydz„Z8�d d{d|„Z9�d d}d~„Z:�d dd€„Z;e<d�ƒdÿd‚dƒ„ƒZ=e<d„ƒdÿd…d†„ƒZ>e<d‡ƒdÿdˆd‰„ƒZ?e<dŠƒdÿd‹dŒ„ƒZ@e<d�ƒdÿdŽd�„ƒZAe<d�ƒdÿd‘d’„ƒZBe<d“ƒdÿd”d•„ƒZCe<d–ƒdÿd—d˜„ƒZDe<d™ƒdÿdšd›„ƒZEe<dœƒdÿd�dž„ƒZFe<dŸƒdÿd d¡„ƒZGe<d¢ƒdÿd£d¤„ƒZHe<d¥ƒdÿd¦d§„ƒZI�dd¨d©„ZJ�ddªd«„ZKdþd¬d­„ZL�dd®d¯„ZMd°d±„ ZNd²d³„ ZOd´dµ„ ZPd¶d·„ ZQd¸d¹„ ZRdºd»„ ZSd¼d½„ ZTd¾d¿„ ZU	r	�ddÁdÂ„ZVdÿdÃdÄ„ZWdÿdÅdÆ„ZXdÿdÇdÈ„ZY	�ddÉdÊ„ZZ�ddËdÌ„Z[dÿdÍdÎ„Z\dÿdÏdÐ„Z]dÿdÑdÒ„Z^dÿdÓdÔ„Z_dÿdÕdÖ„Z`�d d×dØ„ZadÙdÚ„ ZbdÿdÛdÜ„Zc�ddÝdÞ„Zd�ddßdà„Zedádâ„ Zf�ddãdä„Zgdådæ„ Zheidçƒdèdé„ ƒZjeidêƒdëdì„ ƒZkeidíƒdîdï„ ƒZlemdðƒdñdò„ ƒZnemdóƒdôdõ„ ƒZoepdöƒd÷dø„ ƒZq�ddùdú„Zresdûƒdüdý„ ƒZtdS (  Ú	IRBuilderNc                 C   s$   || _ |r
t|jƒnd| _d | _d S )Nr   )Ú_blockr]   r   Ú_anchorÚdebug_metadata©r   r   r   r   r    Ú__init__¾   s   
zIRBuilder.__init__c                 C   s   | j S )z*
        The current basic block.
        )rd   ©r   r   r   r    r   Ã   s   zIRBuilder.blockc                 C   s   | j jS )z'
        The current function.
        )r   Úparentri   r   r   r    ÚfunctionÌ   s   zIRBuilder.functionc                 C   s
   | j jjS )z%
        The current module.
        )r   rj   r9   ri   r   r   r    r9   Ó   s   
zIRBuilder.modulec                 C   s   |j | _| jj |¡| _dS )z‘
        Position immediately before the given instruction.  The current block
        is also changed to the instruction's basic block.
        N©rj   rd   r   Úindexre   ©r   r   r   r   r    Úposition_beforeÚ   s   zIRBuilder.position_beforec                 C   s    |j | _| jj |¡d | _dS )z�
        Position immediately after the given instruction.  The current block
        is also changed to the instruction's basic block.
        r4   Nrl   rn   r   r   r    Úposition_afterâ   s   zIRBuilder.position_afterc                 C   s   || _ d| _dS )z=
        Position at the start of the basic *block*.
        r   N)rd   re   rg   r   r   r    Úposition_at_startê   s   
zIRBuilder.position_at_startc                 C   s   || _ t|jƒ| _dS )z;
        Position at the end of the basic *block*.
        N)rd   r]   r   re   rg   r   r   r    Úposition_at_endñ   s   zIRBuilder.position_at_endr   c                 C   s   | 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.
        )rk   Úappend_basic_block)r   r   r   r   r    rs   ø   s   zIRBuilder.append_basic_blockc                 C   sL   | j j |¡}| j j|= | j j|krd| j _| j|kr$|  jd8  _dS dS )zRemove the given instruction.Nr4   )rd   r   rm   Ú
terminatorre   )r   r   Úidxr   r   r    Úremoveÿ   s   

ÿzIRBuilder.removec              	   c   sP   � | j }|j}|dur|  |¡ n|  |¡ zdV  W |  |¡ dS |  |¡ w )z�
        A context manager which temporarily positions the builder at the end
        of basic block *bb* (but before any terminator).
        N)Úbasic_blockrt   ro   rr   )r   r   Z	old_blockÚtermr   r   r    Ú
goto_block  s   €
zIRBuilder.goto_blockc                 c   s<   � |   | jj¡� dV  W d  ƒ dS 1 sw   Y  dS )z}
        A context manager which temporarily positions the builder at the
        end of the function's entry block.
        N)ry   rk   Úentry_basic_blockri   r   r   r    Úgoto_entry_block  s   €"ÿzIRBuilder.goto_entry_blockc                 c   s0   � |   |¡ |V  | jjd u r|  |¡ d S d S r   )rr   rw   rt   Úbranch)r   ZbbenterZbbexitr   r   r    Ú_branch_helper"  s   €
ÿzIRBuilder._branch_helperc                 c   s    � | j }| jt|jdƒd�}| jt|jdƒd�}|  |||¡}|dur0| |r+ddgnddg¡ |  ||¡� |V  W d  ƒ n1 sDw   Y  |  |¡ dS )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.
        ú.ifr5   ú.endifNéc   r4   ©rw   rs   rb   r   ÚcbranchZset_weightsr}   rr   )r   ÚpredÚlikelyÚbbÚbbifÚbbendÚbrr   r   r    Úif_then)  s   €ÿzIRBuilder.if_thenc           
      c   s¤   � | j }| jt|jdƒd�}| jt|jdƒd�}| jt|jdƒd�}|  |||¡}|dur:| |r5ddgnddg¡ |  ||¡}|  ||¡}	||	fV  |  |¡ dS )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
        r~   r5   z.elser   Nr€   r4   r�   )
r   rƒ   r„   r…   r†   Zbbelser‡   rˆ   ÚthenÚ	otherwiser   r   r    Úif_else@  s   €
zIRBuilder.if_elsec                 C   sD   | j d urd|jvr| j |jd< | jj | j|¡ |  jd7  _d S )NZdbgr4   )rf   Úmetadatard   r   Úinsertre   rn   r   r   r    r   _  s   zIRBuilder._insertc                 C   s"   | j jrJ ‚|  |¡ || j _|S r   )r   Úis_terminatedr   rt   )r   rx   r   r   r    Ú_set_terminatore  s   
zIRBuilder._set_terminatorÚshlc                 C   ó   dS )zC
        Left integer shift:
            name = lhs << rhs
        Nr   ©r   r/   r0   r   r   r   r    r‘   o  ó    zIRBuilder.shlÚlshrc                 C   r’   )zW
        Logical (unsigned) right integer shift:
            name = lhs >> rhs
        Nr   r“   r   r   r    r•   v  r”   zIRBuilder.lshrÚashrc                 C   r’   )zX
        Arithmetic (signed) right integer shift:
            name = lhs >> rhs
        Nr   r“   r   r   r    r–   }  r”   zIRBuilder.ashrÚaddc                 C   r’   )z@
        Integer addition:
            name = lhs + rhs
        Nr   r“   r   r   r    r—   „  r”   zIRBuilder.addÚfaddc                 C   r’   )zG
        Floating-point addition:
            name = lhs + rhs
        Nr   r“   r   r   r    r˜   ‹  r”   zIRBuilder.faddÚsubc                 C   r’   )zC
        Integer subtraction:
            name = lhs - rhs
        Nr   r“   r   r   r    r™   ’  r”   zIRBuilder.subÚfsubc                 C   r’   )zJ
        Floating-point subtraction:
            name = lhs - rhs
        Nr   r“   r   r   r    rš   ™  r”   zIRBuilder.fsubÚmulc                 C   r’   )zF
        Integer multiplication:
            name = lhs * rhs
        Nr   r“   r   r   r    r›      r”   zIRBuilder.mulÚfmulc                 C   r’   )zM
        Floating-point multiplication:
            name = lhs * rhs
        Nr   r“   r   r   r    rœ   §  r”   zIRBuilder.fmulÚudivc                 C   r’   )zI
        Unsigned integer division:
            name = lhs / rhs
        Nr   r“   r   r   r    r�   ®  r”   zIRBuilder.udivÚsdivc                 C   r’   )zG
        Signed integer division:
            name = lhs / rhs
        Nr   r“   r   r   r    rž   µ  r”   zIRBuilder.sdivÚfdivc                 C   r’   )zG
        Floating-point division:
            name = lhs / rhs
        Nr   r“   r   r   r    rŸ   ¼  r”   zIRBuilder.fdivÚuremc                 C   r’   )zJ
        Unsigned integer remainder:
            name = lhs % rhs
        Nr   r“   r   r   r    r    Ã  r”   zIRBuilder.uremÚsremc                 C   r’   )zH
        Signed integer remainder:
            name = lhs % rhs
        Nr   r“   r   r   r    r¡   Ê  r”   zIRBuilder.sremÚfremc                 C   r’   )zH
        Floating-point remainder:
            name = lhs % rhs
        Nr   r“   r   r   r    r¢   Ñ  r”   zIRBuilder.fremÚorc                 C   r’   )zB
        Bitwise integer OR:
            name = lhs | rhs
        Nr   r“   r   r   r    Úor_Ø  r”   zIRBuilder.or_Úandc                 C   r’   )zC
        Bitwise integer AND:
            name = lhs & rhs
        Nr   r“   r   r   r    Úand_ß  r”   zIRBuilder.and_Úxorc                 C   r’   )zC
        Bitwise integer XOR:
            name = lhs ^ rhs
        Nr   r“   r   r   r    r§   æ  r”   zIRBuilder.xorZsaddc                 C   r’   )zn
        Signed integer addition with overflow:
            name = {result, overflow bit} = lhs + rhs
        Nr   r“   r   r   r    Úsadd_with_overflowí  r”   zIRBuilder.sadd_with_overflowZsmulc                 C   r’   )zt
        Signed integer multiplication with overflow:
            name = {result, overflow bit} = lhs * rhs
        Nr   r“   r   r   r    Úsmul_with_overflowô  r”   zIRBuilder.smul_with_overflowZssubc                 C   r’   )zq
        Signed integer subtraction with overflow:
            name = {result, overflow bit} = lhs - rhs
        Nr   r“   r   r   r    Ússub_with_overflowû  r”   zIRBuilder.ssub_with_overflowZuaddc                 C   r’   )zp
        Unsigned integer addition with overflow:
            name = {result, overflow bit} = lhs + rhs
        Nr   r“   r   r   r    Úuadd_with_overflow  r”   zIRBuilder.uadd_with_overflowZumulc                 C   r’   )zv
        Unsigned integer multiplication with overflow:
            name = {result, overflow bit} = lhs * rhs
        Nr   r“   r   r   r    Úumul_with_overflow	  r”   zIRBuilder.umul_with_overflowZusubc                 C   r’   )zs
        Unsigned integer subtraction with overflow:
            name = {result, overflow bit} = lhs - rhs
        Nr   r“   r   r   r    Úusub_with_overflow  r”   zIRBuilder.usub_with_overflowc                 C   sD   t |jtjƒrt |jd|jj ¡}nt |jd¡}| j|||d�S )zG
        Bitwise integer complement:
            name = ~value
        )éÿÿÿÿr®   r5   )r6   r   r   Ú
VectorTyper   ÚConstantÚcountr§   )r   Úvaluer   r0   r   r   r    Únot_  s   zIRBuilder.not_c                 C   s   | j t |jd¡||d�S )z=
        Integer negative:
            name = -value
        r   r5   )r™   r   r°   r   )r   r²   r   r   r   r    Úneg&  s   zIRBuilder.negÚfnegr   c                 C   r’   )zB
        Floating-point negative:
            name = -arg
        Nr   )r   r   r   r   r   r   r    rµ   -  r”   zIRBuilder.fnegc                 C   s^   zt | }W n ty   td|f ƒ‚w |dvr|| }tj| j||||d�}|  |¡ |S )Nzinvalid comparison %r for icmp)r   r   r5   )Ú_CMP_MAPÚKeyErrorr.   r   Z	ICMPInstrr   r   )r   ÚprefixÚcmpopr/   r0   r   Úopr   r   r   r    Ú_icmp8  s   ÿ
zIRBuilder._icmpc                 C   ó   |   d||||¡S )zŒ
        Signed integer comparison:
            name = lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>='
        Ús©r»   ©r   r¹   r/   r0   r   r   r   r    Úicmp_signedC  ó   zIRBuilder.icmp_signedc                 C   r¼   )z›
        Unsigned integer (or pointer) comparison:
            name = lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>='
        Úur¾   r¿   r   r   r    Úicmp_unsignedL  rÁ   zIRBuilder.icmp_unsignedc                 C   ó@   |t v rdt |  }n|}tj| j|||||d�}|  |¡ |S )z¢
        Floating-point ordered comparison:
            name = lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
        Úo©r   r   ©r¶   r   Z	FCMPInstrr   r   ©r   r¹   r/   r0   r   r   rº   r   r   r   r    Úfcmp_orderedU  ó   ÿ
zIRBuilder.fcmp_orderedc                 C   rÄ   )z¤
        Floating-point unordered comparison:
            name = lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
        rÂ   rÆ   rÇ   rÈ   r   r   r    Úfcmp_unorderede  rÊ   zIRBuilder.fcmp_unorderedc                 C   ó&   t j| j|||||d�}|  |¡ |S )zN
        Ternary select operator:
            name = cond ? lhs : rhs
        rÆ   )r   ZSelectInstrr   r   )r   Úcondr/   r0   r   r   r   r   r   r    Úselectu  s
   ÿ
zIRBuilder.selectÚtruncc                 C   r’   )z_
        Truncating integer downcast to a smaller type:
            name = (typ) value
        Nr   ©r   r²   rY   r   r   r   r    rÏ   ƒ  r”   zIRBuilder.truncÚzextc                 C   r’   )z`
        Zero-extending integer upcast to a larger type:
            name = (typ) value
        Nr   rÐ   r   r   r    rÑ   Š  r”   zIRBuilder.zextÚsextc                 C   r’   )z`
        Sign-extending integer upcast to a larger type:
            name = (typ) value
        Nr   rÐ   r   r   r    rÒ   ‘  r”   zIRBuilder.sextÚfptruncc                 C   r’   )z`
        Floating-point downcast to a less precise type:
            name = (typ) value
        Nr   rÐ   r   r   r    rÓ   ˜  r”   zIRBuilder.fptruncÚfpextc                 C   r’   )z^
        Floating-point upcast to a more precise type:
            name = (typ) value
        Nr   rÐ   r   r   r    rÔ   Ÿ  r”   zIRBuilder.fpextÚbitcastc                 C   r’   )zZ
        Pointer cast to a different pointer type:
            name = (typ) value
        Nr   rÐ   r   r   r    rÕ   ¦  r”   zIRBuilder.bitcastÚaddrspacecastc                 C   r’   )z[
        Pointer cast to a different address space:
            name = (typ) value
        Nr   rÐ   r   r   r    rÖ   ­  r”   zIRBuilder.addrspacecastÚfptouic                 C   r’   )z\
        Convert floating-point to unsigned integer:
            name = (typ) value
        Nr   rÐ   r   r   r    r×   ´  r”   zIRBuilder.fptouiÚuitofpc                 C   r’   )z\
        Convert unsigned integer to floating-point:
            name = (typ) value
        Nr   rÐ   r   r   r    rØ   »  r”   zIRBuilder.uitofpÚfptosic                 C   r’   )zZ
        Convert floating-point to signed integer:
            name = (typ) value
        Nr   rÐ   r   r   r    rÙ   Â  r”   zIRBuilder.fptosiÚsitofpc                 C   r’   )zZ
        Convert signed integer to floating-point:
            name = (typ) value
        Nr   rÐ   r   r   r    rÚ   É  r”   zIRBuilder.sitofpÚptrtointc                 C   r’   )zÙ
        Cast pointer to integer:
            name = (typ) value

        Warning: Since LLVM 22, this is affected by changes in pointer
        provenance behavior. See docs :ref:`llvm22-pointer-provenance`.
        Nr   rÐ   r   r   r    rÛ   Ð  r”   zIRBuilder.ptrtointÚinttoptrc                 C   r’   )zÙ
        Cast integer to pointer:
            name = (typ) value

        Warning: Since LLVM 22, this is affected by changes in pointer
        provenance behavior. See docs :ref:`llvm22-pointer-provenance`.
        Nr   rÐ   r   r   r    rÜ   Ú  r”   zIRBuilder.inttoptrc                 C   sb   |du rnt |tjtjfƒrt |jtjƒsJ ‚n	t t d¡|¡}t | j	|||¡}|  
|¡ |S )zl
        Stack-allocate a slot for *size* elements of the given type.
        (default one element)
        Né    )r6   r   ÚValuer°   r   r   r7   r   ZAllocaInstrr   r   )r   rY   Úsizer   Úalr   r   r    Úallocaè  s   
zIRBuilder.allocac                 C   sP   t |jtjƒsd}t||jt|ƒf ƒ‚tj| j|||d�}||_	|  
|¡ |S ©zf
        Load value from pointer, with optional guaranteed alignment:
            name = *ptr
        z5cannot load from value of type %s (%r): not a pointer)rY   )r6   r   r   ÚPointerTyper8   Ústrr   Z	LoadInstrr   Úalignr   )r   Úptrr   rå   rY   ÚmsgÚldr   r   r    Úloadú  s   
zIRBuilder.loadc                 C   sv   t |jtjƒsd}t||jt|ƒf ƒ‚|jjs)|jj|jkr)td|j|jf ƒ‚t 	| j
||¡}||_|  |¡ |S ©ze
        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)r6   r   r   rã   r8   rä   Ú	is_opaqueÚpointeer   Z
StoreInstrr   rå   r   )r   r²   ræ   rå   rç   Ústr   r   r    Ústore  s   
ÿ
zIRBuilder.storec                 C   sN   t |jtjƒsd}t||jt|ƒf ƒ‚tj| j|||||d�}|  	|¡ |S râ   )
r6   r   r   rã   r8   rä   r   ZLoadAtomicInstrr   r   )r   ræ   Úorderingrå   r   rY   rç   rè   r   r   r    Úload_atomic  s   ÿ
zIRBuilder.load_atomicc                 C   sl   t |jtjƒsd}t||jt|ƒf ƒ‚|jj|jkr%td|j|jf ƒ‚t | j	||||¡}|  
|¡ |S rê   )r6   r   r   rã   r8   rä   rì   r   ZStoreAtomicInstrr   r   )r   r²   ræ   rï   rå   rç   rí   r   r   r    Ústore_atomic$  s   
ÿÿ
zIRBuilder.store_atomicc                 C   s    t  | jd||¡}|  |¡ |S )zF
        Create a switch-case with a single *default* target.
        Úswitch)r   ZSwitchInstrr   r�   )r   r²   ÚdefaultZswtr   r   r    rò   8  ó   
zIRBuilder.switchc                 C   ó    t  | jd|g¡}|  |¡ |S )z3
        Unconditional branch to *target*.
        rˆ   ©r   ZBranchr   r�   )r   Útargetrˆ   r   r   r    r|   @  rô   zIRBuilder.branchc                 C   s$   t  | jd|||g¡}|  |¡ |S )zV
        Conditional branch to *truebr* if *cond* is true, else to *falsebr*.
        rˆ   )r   ZConditionalBranchr   r�   )r   rÍ   ZtruebrZfalsebrrˆ   r   r   r    r‚   H  s
   
ÿ
zIRBuilder.cbranchc                 C   s   t  | jd|¡}|  |¡ |S )z3
        Indirect branch to target *addr*.
        Z
indirectbr)r   ZIndirectBranchr   r�   )r   Úaddrrˆ   r   r   r    Úbranch_indirectQ  s   
zIRBuilder.branch_indirectc                 C   s   |   t | jd¡¡S )z7
        Return from function without a value.
        zret void©r�   r   ZRetr   ri   r   r   r    Úret_voidY  s   ÿzIRBuilder.ret_voidc                 C   s   |   t | jd|¡¡S )z>
        Return from function with the given *value*.
        rA   rú   )r   r²   r   r   r    rA   `  s   ÿzIRBuilder.retc                 C   rõ   )z0
        Resume an in-flight exception.
        Úresumerö   )r   Ú
landingpadrˆ   r   r   r    rü   g  rô   zIRBuilder.resumeFc	           
      C   s,   t j| j||||||||d�	}	|  |	¡ |	S )zP
        Call function *fn* with *args*:
            name = fn(args...)
        )r   ÚcconvÚtailÚfastmathÚattrsÚ	arg_attrs)r   Z	CallInstrr   r   )
r   r'   Úargsr   rþ   rÿ   r   r  r  Úinstr   r   r    r=   q  s   þ
zIRBuilder.callc                 C   s   t  ||||¡}|  |||¡S )z#
        Inline assembler.
        )r   Z	InlineAsmr=   )r   ÚftypeÚasmÚ
constraintr  Úside_effectr   r   r   r    r  }  s   zIRBuilder.asmc                 C   s$   t  |g ¡}|  |dd| g d|¡S )zo
        Load a register value into an LLVM value.
          Example: v = load_reg(IntType(32), "eax")
        r   z={%s}F)r   r:   r  )r   Úreg_typeÚreg_namer   r  r   r   r    Úload_reg„  s   zIRBuilder.load_regc                 C   s,   t  t  ¡ |g¡}|  |dd| |gd|¡S )z“
        Store an LLVM value inside a register
        Example:
          store_reg(Constant(IntType(32), 0xAAAAAAAA), IntType(32), "eax")
        r   z{%s}T)r   r:   ÚVoidTyper  )r   r²   r	  r
  r   r  r   r   r    Ú	store_regŒ  s   zIRBuilder.store_regc
                 C   s.   t j| j|||||||||	d�
}
|  |
¡ |
S )N)r   rþ   r   r  r  )r   ZInvokeInstrr   r�   )r   r'   r  Z	normal_toZ	unwind_tor   rþ   r   r  r  r  r   r   r    Úinvoke•  s   ý
zIRBuilder.invokec                 C   rÌ   )zo
        Compute effective address (getelementptr):
            name = getelementptr ptr, <indices...>
        )Úinboundsr   Úsource_etype)r   ZGEPInstrr   r   )r   ræ   Úindicesr  r   r  r   r   r   r    Úgep   s   þ
zIRBuilder.gepc                 C   ó"   t j| j|||d�}|  |¡ |S )z4
        Returns the value at position idx.
        r5   )r   ZExtractElementr   r   )r   Úvectorru   r   r   r   r   r    Úextract_element­  s   
zIRBuilder.extract_elementc                 C   ó$   t j| 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.
        r5   )r   ZInsertElementr   r   )r   r  r²   ru   r   r   r   r   r    Úinsert_elementµ  s
   ÿ
zIRBuilder.insert_elementc                 C   r  )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.
        r5   )r   ZShuffleVectorr   r   )r   Zvector1Zvector2Úmaskr   r   r   r   r    Úshuffle_vector¿  s
   ÿ
zIRBuilder.shuffle_vectorc                 C   s6   t |ttfƒs
|g}tj| j|||d�}|  |¡ |S )z=
        Extract member number *idx* from aggregate.
        r5   )r6   ÚtupleÚlistr   ZExtractValuer   r   )r   Úaggru   r   r   r   r   r    Úextract_valueÎ  s
   
zIRBuilder.extract_valuec                 C   s8   t |ttfƒs
|g}tj| j||||d�}|  |¡ |S )zI
        Insert *value* into member number *idx* from aggregate.
        r5   )r6   r  r  r   ZInsertValuer   r   )r   r  r²   ru   r   r   r   r   r    Úinsert_valueØ  s
   
zIRBuilder.insert_valuec                 C   r  )NrÆ   )r   ZPhiInstrr   r   )r   rY   r   r   r  r   r   r    Úphiä  s   
zIRBuilder.phic                 C   s   t  | j¡}|  |¡ |S r   )r   ZUnreachabler   r�   )r   r  r   r   r    Úunreachableë  s   
zIRBuilder.unreachablec                 C   rÌ   )Nr5   )r   Z	AtomicRMWr   r   )r   rº   ræ   rX   rï   r   r  r   r   r    Ú
atomic_rmwð  s
   ÿ
zIRBuilder.atomic_rmwc              	   C   s8   |du r|n|}t j| 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.
        Nr5   )r   ZCmpXchgr   r   )r   ræ   ÚcmprX   rï   Zfailorderingr   r  r   r   r    Úcmpxchgö  s   ÿ
zIRBuilder.cmpxchgc                 C   s    t  | j|||¡}|  |¡ |S r   )r   ZLandingPadInstrr   r   )r   rY   r   Úcleanupr  r   r   r    rý   	  s   
zIRBuilder.landingpadc                 C   s   | j  d¡}|  ||g¡S )z?
        Optimizer hint: assume *cond* is always true.
        zllvm.assume)r9   r<   r=   )r   rÍ   r'   r   r   r    Úassume  s   zIRBuilder.assumec                 C   r  )z¢
        Add a memory barrier, preventing certain reorderings of load and/or
        store accesses with
        respect to other processors and devices.
        r5   )r   ZFencer   r   )r   rï   Ztargetscoper   r  r   r   r    Úfence  s   
zIRBuilder.fencec                 C   s   t  | j|¡}|  |¡ |S )a  
        Puts a single-line comment into the generated IR. This will be ignored
        by LLVM, but can be useful for debugging the output of a compiler. Adds
        a comment to the source file.

        * *text* is a string that does not contain new line characters.
        )r   ÚCommentr   r   )r   Útextr  r   r   r    Úcomment  s   
zIRBuilder.commentz
llvm.bswapc                 C   r’   )zv
        Used to byte swap integer values with an even number of bytes (positive
        multiple of 16 bits)
        Nr   ©r   rÍ   r   r   r    Úbswap+  r”   zIRBuilder.bswapzllvm.bitreversec                 C   r’   )zp
        Reverse the bitpattern of an integer value; for example 0b10110110
        becomes 0b01101101.
        Nr   r*  r   r   r    Ú
bitreverse2  r”   zIRBuilder.bitreversez
llvm.ctpopc                 C   r’   )z;
        Counts the number of bits set in a value.
        Nr   r*  r   r   r    Úctpop9  r”   zIRBuilder.ctpopz	llvm.ctlzc                 C   r’   )z€
        Counts leading zero bits in *value*. Boolean *flag* indicates whether
        the result is defined for ``0``.
        Nr   ©r   rÍ   rQ   r   r   r    Úctlz?  r”   zIRBuilder.ctlzz	llvm.cttzc                 C   r’   )z�
        Counts trailing zero bits in *value*. Boolean *flag* indicates whether
        the result is defined for ``0``.
        Nr   r.  r   r   r    ÚcttzF  r”   zIRBuilder.cttzzllvm.fmac                 C   r’   )z;
        Perform the fused multiply-add operation.
        Nr   )r   rT   rU   rV   r   r   r    ÚfmaM  r”   zIRBuilder.fmac                 C   sv   |st dƒ‚t|tjtjfƒst d| ƒ‚t|jtjƒr"|jjdks)t d|j ƒ‚d}| j 	||g¡}|  
||g|¡S )z:
        Convert from an i16 to the given FP type
        zexpected a float return typerL   é   zexpected an i16 type, got %szllvm.convert.from.fp16)r8   r6   r   rM   rN   r   r7   rP   r9   r<   r=   )r   rT   Útor   r   r'   r   r   r    Úconvert_from_fp16S  s   zIRBuilder.convert_from_fp16zllvm.convert.to.fp16c                 C   r’   )z7
        Convert the given FP number to an i16
        Nr   )r   rT   r   r   r    Úconvert_to_fp16b  r”   zIRBuilder.convert_to_fp16r   rC   r"   )Nr   )r   NN)r   N)r   NFr   r   N)r   Nr   r   N)Fr   N)r   F)uÚ__name__Ú
__module__Ú__qualname__rh   Úpropertyr   rw   rk   r9   ro   rp   rq   rr   rs   rv   Ú
contextlibÚcontextmanagerry   r{   r}   r‰   rŒ   r   r�   r1   r‘   r•   r–   r—   r˜   r™   rš   r›   rœ   r�   rž   rŸ   r    r¡   r¢   r¤   r¦   r§   rD   r¨   r©   rª   r«   r¬   r­   r³   r´   r+   rµ   r»   rÀ   rÃ   rÉ   rË   rÎ   rZ   rÏ   rÑ   rÒ   rÓ   rÔ   rÕ   rÖ   r×   rØ   rÙ   rÚ   rÛ   rÜ   rá   ré   rî   rð   rñ   rò   r|   r‚   rù   rû   rA   rü   r=   r  r  r  r  r  r  r  r  r  r  r  r   r!  r#  rý   r%  r&  r)  rK   r+  r,  r-  rR   r/  r0  rW   r1  r4  rO   r5  r   r   r   r    rc   ½   s@   




	









			
	
ÿ



ÿ














rc   )r:  r$   Úllvmlite.irr   r   r   r¶   ÚInstructionr+   r1   rD   rG   rK   rO   rR   rW   Z	CastInstrrZ   rb   Úobjectrc   r   r   r   r    Ú<module>   s*    ú
