
    Ǆgф                     >   d Z ddlZddlZddlZddlmZ ddlmZmZmZ ddl	m
Z
mZmZ  e eeej                                e eeej"                              z   e eed            z  Z ej&                  d      Zdd	d
ddddZi fdZd Zd Z G d de      Z G d de      Z G d de      Z e       Z G d de
eee      Z G d de      Z G d de
ee      Z  G d de       Z! G d  d!e
ee      Z" G d" d#e      Z# G d$ d%e       Z$ G d& d'      Z% G d( d)e       Z& G d* d+e ee      Z' G d, d-e'      Z( G d. d/e)      Z* G d0 d1e*      Z+ G d2 d3e'      Z, G d4 d5e*      Z- G d6 d7e       Z. G d8 d9e.      Z/ G d: d;e.      Z0 G d< d=e       Z1 G d> d?e      Z2y)@z_
Classes that are LLVM values: Value, Constant...
Instructions are in the instructions module.
    N)MappingProxyType)valuestypes_utils)_StrCaching_StringReferenceCaching_HasMetadataz !#$%&'()*+,-./:;<=>?@[]^_`{|}~z[-a-zA-Z$._][-a-zA-Z$._0-9]*$gtlteqnegele)><==!=z>=z<=c                 $   t        | t              r| j                         } t        | t        t        f      sJ |s/t        d      D ]!  }|t        v rt        |      ||<   d|z  ||<   # | D cg c]  }||   	 }}dj                  |      S c c}w )z
    Escape the given bytestring for safe use as a LLVM array constant.
    Any unicode string input is first encoded with utf8 into bytes.
       z\%02x )	
isinstancestrencodebytes	bytearrayrange_VALID_CHARSchrjoin)text_mapchbufs       Z/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/llvmlite/ir/values.py_escape_stringr%      s    
 ${{}dUI.///* 	)B\!r7R#b=R		) #
#48
#C
#773< $s   .Bc                       fd}|S )Nc                 B    t        j                  |       fd       }|S )Nc                 8   | j                   |j                   k7  r&t        d| j                   d|j                   d      dj                  | j                   | j                         |j                   |j                               }t	        | j                   |      S )N%Operands must be the same type, got (, )z{0} ({1} {2}, {3} {4}))type
ValueErrorformatget_referenceFormattedConstant)lhsrhsfmtopnames      r$   wrappedz%_binop.<locals>.wrap.<locals>.wrapped5   s~    xx388# $'HHchh"8 9 9 +11&25((C<M<M<O25((C<M<M<OQC %SXXs33    	functoolswrapsfnr5   r4   s     r$   wrapz_binop.<locals>.wrap4   s%    			4 
	4 r6    r4   r<   s   ` r$   _binopr?   3   s     Kr6   c                       fd}|S )Nc                 F     t        j                          fd       }|S )Nc                      | |       || j                   k(  r| S dj                  | j                   | j                         |      }t        ||      S )Nz{0} ({1} {2} to {3}))r,   r.   r/   r0   )selftypopr;   r4   s      r$   r5   z&_castop.<locals>.wrap.<locals>.wrappedF   sQ    tSMdii'..vtyy/3/A/A/CSJB$S"--r6   r7   r:   s   ` r$   r<   z_castop.<locals>.wrapE   s%    			. 
	. r6   r=   r>   s   ` r$   _castoprF   D   s     Kr6   c                      e Zd ZdZ ed      d        Z ed      d        Z ed      d        Z ed      d	        Z ed
      d        Z	 ed      d        Z
 ed      d        Z ed      d        Z ed      d        Z ed      d        Z ed      d        Z ed      d        Z ed      d        Z ed      d        Z ed      d        Z ed       d!        Z ed"      d#        Z ed$      d%        Zd& Zd' Zd( Zd) Zd* Zd+ Zd, Zd- Z ed.      d/        Z  ed0      d1        Z! ed2      d3        Z" ed4      d5        Z# ed6      d7        Z$ ed8      d9        Z% ed:      d;        Z& ed<      d=        Z' ed>      d?        Z( ed@      dA        Z) edB      dC        Z* edD      dE        Z+dF Z,yG)H_ConstOpMixinzQ
    A mixin defining constant operations, for use in constant-like classes.
    shlc                      y)z<
        Left integer shift:
            lhs << rhs
        Nr=   rC   others     r$   rI   z_ConstOpMixin.shl]       r6   lshrc                      y)zP
        Logical (unsigned) right integer shift:
            lhs >> rhs
        Nr=   rK   s     r$   rN   z_ConstOpMixin.lshrd   rM   r6   ashrc                      y)zQ
        Arithmetic (signed) right integer shift:
            lhs >> rhs
        Nr=   rK   s     r$   rP   z_ConstOpMixin.ashrk   rM   r6   addc                      y)z9
        Integer addition:
            lhs + rhs
        Nr=   rK   s     r$   rR   z_ConstOpMixin.addr   rM   r6   faddc                      y)z@
        Floating-point addition:
            lhs + rhs
        Nr=   rK   s     r$   rT   z_ConstOpMixin.faddy   rM   r6   subc                      y)z<
        Integer subtraction:
            lhs - rhs
        Nr=   rK   s     r$   rV   z_ConstOpMixin.sub   rM   r6   fsubc                      y)zC
        Floating-point subtraction:
            lhs - rhs
        Nr=   rK   s     r$   rX   z_ConstOpMixin.fsub   rM   r6   mulc                      y)z?
        Integer multiplication:
            lhs * rhs
        Nr=   rK   s     r$   rZ   z_ConstOpMixin.mul   rM   r6   fmulc                      y)zF
        Floating-point multiplication:
            lhs * rhs
        Nr=   rK   s     r$   r\   z_ConstOpMixin.fmul   rM   r6   udivc                      y)zB
        Unsigned integer division:
            lhs / rhs
        Nr=   rK   s     r$   r^   z_ConstOpMixin.udiv   rM   r6   sdivc                      y)z@
        Signed integer division:
            lhs / rhs
        Nr=   rK   s     r$   r`   z_ConstOpMixin.sdiv   rM   r6   fdivc                      y)z@
        Floating-point division:
            lhs / rhs
        Nr=   rK   s     r$   rb   z_ConstOpMixin.fdiv   rM   r6   uremc                      y)zC
        Unsigned integer remainder:
            lhs % rhs
        Nr=   rK   s     r$   rd   z_ConstOpMixin.urem   rM   r6   sremc                      y)zA
        Signed integer remainder:
            lhs % rhs
        Nr=   rK   s     r$   rf   z_ConstOpMixin.srem   rM   r6   fremc                      y)zA
        Floating-point remainder:
            lhs % rhs
        Nr=   rK   s     r$   rh   z_ConstOpMixin.frem   rM   r6   orc                      y)z;
        Bitwise integer OR:
            lhs | rhs
        Nr=   rK   s     r$   or_z_ConstOpMixin.or_   rM   r6   andc                      y)z<
        Bitwise integer AND:
            lhs & rhs
        Nr=   rK   s     r$   and_z_ConstOpMixin.and_   rM   r6   xorc                      y)z<
        Bitwise integer XOR:
            lhs ^ rhs
        Nr=   rK   s     r$   rp   z_ConstOpMixin.xor   rM   r6   c           	         |dz   }	 t         |   }|dk(  r|dv s||z   }| j                  |j                  k7  r&t        d| j                  d|j                  d      d	j	                  ||| j                  | j                         |j                  |j                               }t        t        j                  d
      |      S # t        $ r t        d|d|      w xY w)Ncmpzinvalid comparison z for i)r   r   r)   r*   r+   z{0} {1} ({2} {3}, {4} {5})   )	_CMP_MAPKeyErrorr-   r,   r.   r/   r0   r   IntType)rC   prefixsigncmpoprL   insrE   r3   s           r$   _cmpz_ConstOpMixin._cmp   s    un	L%B #%<"7B99

" $		5::7 8 8 +11IIt))+JJ++-/
 !q!1377  	LucJKK	Ls   	C Cc                 *    | j                  dd||      S )z
        Signed integer comparison:
            lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>='
        rt   sr}   rC   r{   rL   s      r$   icmp_signedz_ConstOpMixin.icmp_signed        yyc5%00r6   c                 *    | j                  dd||      S )z
        Unsigned integer (or pointer) comparison:
            lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>='
        rt   ur   r   s      r$   icmp_unsignedz_ConstOpMixin.icmp_unsigned   r   r6   c                 *    | j                  dd||      S )z
        Floating-point ordered comparison:
            lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
        for   r   s      r$   fcmp_orderedz_ConstOpMixin.fcmp_ordered  r   r6   c                 *    | j                  dd||      S )z
        Floating-point unordered comparison:
            lhs <cmpop> rhs

        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
        r   r   r   r   s      r$   fcmp_unorderedz_ConstOpMixin.fcmp_unordered  r   r6   c                    t        | j                  t        j                        r8t	        j
                  | j                  d| j                  j                  z        }n t	        j
                  | j                  d      }| j                  |      S )z@
        Bitwise integer complement:
            ~value
        )r   )r   r,   r   
VectorTyper   Constantcountrp   )rC   r2   s     r$   not_z_ConstOpMixin.not_  s[    
 dii!1!12//$))UTYY__-DEC//$))R0Cxx}r6   c                 d    t        j                  | j                  d      }|j                  |       S )z6
        Integer negative:
            -value
        r   )r   r   r,   rV   )rC   zeros     r$   negz_ConstOpMixin.neg$  s&    
 tyy!,xx~r6   c                     dj                  | j                  | j                               }t        | j                  |      S )z=
        Floating-point negative:
            -value
        zfneg ({0} {1}))r.   r,   r/   r0   )rC   r3   s     r$   fnegz_ConstOpMixin.fneg,  s4    
 %%dii1C1C1EF C00r6   truncc                      y)z@
        Truncating integer downcast to a smaller type.
        Nr=   rC   rD   s     r$   r   z_ConstOpMixin.trunc8  rM   r6   zextc                      y)z@
        Zero-extending integer upcast to a larger type
        Nr=   r   s     r$   r   z_ConstOpMixin.zext>  rM   r6   sextc                      y)zA
        Sign-extending integer upcast to a larger type.
        Nr=   r   s     r$   r   z_ConstOpMixin.sextD  rM   r6   fptruncc                      y)zA
        Floating-point downcast to a less precise type.
        Nr=   r   s     r$   r   z_ConstOpMixin.fptruncJ  rM   r6   fpextc                      y)z?
        Floating-point upcast to a more precise type.
        Nr=   r   s     r$   r   z_ConstOpMixin.fpextP  rM   r6   bitcastc                      y)z;
        Pointer cast to a different pointer type.
        Nr=   r   s     r$   r   z_ConstOpMixin.bitcastV  rM   r6   fptouic                      y)z=
        Convert floating-point to unsigned integer.
        Nr=   r   s     r$   r   z_ConstOpMixin.fptoui\  rM   r6   uitofpc                      y)z=
        Convert unsigned integer to floating-point.
        Nr=   r   s     r$   r   z_ConstOpMixin.uitofpb  rM   r6   fptosic                      y)z;
        Convert floating-point to signed integer.
        Nr=   r   s     r$   r   z_ConstOpMixin.fptosih  rM   r6   sitofpc                      y)z;
        Convert signed integer to floating-point.
        Nr=   r   s     r$   r   z_ConstOpMixin.sitofpn  rM   r6   ptrtointc                     t        | j                  t        j                        sd}t	        || j                  fz        t        |t        j
                        st	        d|d      y)z*
        Cast pointer to integer.
        z2can only call ptrtoint() on pointer type, not '%s'z*can only ptrtoint() to integer type, not ''N)r   r,   r   PointerType	TypeErrorrx   rC   rD   msgs      r$   r   z_ConstOpMixin.ptrtointt  s[    
 $))U%6%67FCC499,.//#u}}-"% & & .r6   inttoptrc                     t        | j                  t        j                        sd}t	        || j                  fz        t        |t        j
                        st	        d|d      y)z*
        Cast integer to pointer.
        z7can only call inttoptr() on integer constants, not '%s'z*can only inttoptr() to pointer type, not 'r   N)r   r,   r   rx   r   r   r   s      r$   r   z_ConstOpMixin.inttoptr  s[    
 $))U]]3KCC499,.//#u001"% & & 2r6   c                 $   t        | j                  t        j                        st	        d| j                  d      | j                  }|D ]  }|j                  |      } |D cg c],  }dj                  |j                  |j                               . }}dj                  | j                  j                  | j                  | j                         dj                  |            }t        |j                  | j                        |      S c c}w )z>
        Call getelementptr on this pointer constant.
        z/can only call gep() on pointer constants, not 'r   {0} {1}z!getelementptr ({0}, {1} {2}, {3})r*   )r   r,   r   r   r   gepr.   r/   pointeer   r0   
as_pointer	addrspace)rC   indicesouttypert   idx
strindicesrE   s          r$   r   z_ConstOpMixin.gep  s     $))U%6%67#yy+ , , )) 	%Akk!nG	% ")*  &&sxx1B1B1DE *
 * 177IItyy $))J"79 !!3!3DNN!CRHH*s   &1DN)-__name__
__module____qualname____doc__r?   rI   rN   rP   rR   rT   rV   rX   rZ   r\   r^   r`   rb   rd   rf   rh   rl   ro   rp   r}   r   r   r   r   r   r   r   rF   r   r   r   r   r   r   r   r   r   r   r   r   r   r=   r6   r$   rH   rH   T   s    E]  F^  F^  E]  F^  E]  F^  E]  F^  F^  F^  F^  F^  F^  F^  D\  E]  E] 8*1111
1 W 
 V_ 
 V_ 
 Y 
 W 
 Y 
 X 
 X 
 X 
 X 
 Z	& 	& Z	& 	&Ir6   rH   c                       e Zd ZdZd Zy)Valuez(
    The base class for all values.
    c                 P    d| j                   j                  d| j                  dS )N<ir.z type='z' ...>)	__class__r   r,   rC   s    r$   __repr__zValue.__repr__  s    *...*A*A499NNr6   N)r   r   r   r   r   r=   r6   r$   r   r     s    Or6   r   c                       e Zd ZdZd Zy)
_Undefinedz0
    'undef': a value for undefined values.
    c                 `    	 t         S # t        $ r t        j                  t              cY S w xY wN)	Undefined	NameErrorobject__new__r   )clss    r$   r   z_Undefined.__new__  s+    	. 	.>>*--	.s    "--N)r   r   r   r   r   r=   r6   r$   r   r     s    .r6   r   c                   j    e Zd ZdZd Zd Zd Zed        Zed        Z	e
d        Zd Zd	 Zd
 Zd Zy)r   z 
    A constant LLVM value.
    c                     t        |t        j                        sJ t        |t        j                        rJ || _        |j                  |      }|| _        y r   )r   r   TypeVoidTyper,   wrap_constant_valueconstantrC   rD   r   s      r$   __init__zConstant.__init__  sH    #uzz***c5>>222	**84 r6   c                 V    dj                  | j                  | j                               S Nr   r.   r,   r/   r   s    r$   
_to_stringzConstant._to_string  "    		4+=+=+?@@r6   c                 D   | j                   | j                  j                  }|S | j                   t        u rd}|S t	        | j                   t
              r&dj                  t        | j                               }|S | j                  j                  | j                         }|S )Nundefzc"{0}")	r   r,   nullr   r   r   r.   r%   format_constantrC   vals     r$   _get_referencezConstant._get_reference  s    == ))..C 
 ]]i'C 
 y1//."?@C
 
 ))++DMM:C
r6   c                     |D cg c]  }|j                    }}t        |      dk(  rt        d      |d   }|D ]  }||k7  s	t        d        | t	        j
                  |t        |            |      S c c}w )zO
        Construct a literal array constant made of the given members.
        r   zneed at least one elementz$all elements must have the same type)r,   lenr-   r   r   	ArrayType)r   elemseltystyrL   s         r$   literal_arrayzConstant.literal_array  s    
 "''2rww''s8q=899V 	HEU{ FGG	H 5??2s5z2E:: (s   A5c                 v    |D cg c]  }|j                    }} | t        j                  |      |      S c c}w )zS
        Construct a literal structure constant made of the given members.
        )r,   r   LiteralStructType)r   r   r   r   s       r$   literal_structzConstant.literal_struct  s8    
 "''2rww''5**3/77 (s   6c                     t        | j                  t        j                        st	        d      | j                  j
                  S )Nz)Only pointer constant have address spaces)r   r,   r   r   r   r   r   s    r$   r   zConstant.addrspace  s2    $))U%6%67GHHyy"""r6   c                 R    t        |t              rt        |       t        |      k(  S yNF)r   r   r   rK   s     r$   __eq__zConstant.__eq__  s"    eX&t9E
**r6   c                 &    | j                  |       S r   r   rK   s     r$   __ne__zConstant.__ne__      ;;u%%%r6   c                 *    t        t        |             S r   )hashr   r   s    r$   __hash__zConstant.__hash__  s    CIr6   c                 <    d| j                   d| j                  dS )Nz<ir.Constant type='z' value=r   )r,   r   r   s    r$   r   zConstant.__repr__  s    59YYNNr6   N)r   r   r   r   r   r   r   classmethodr   r   propertyr   r   r   r   r   r=   r6   r$   r   r     sh    !A ; ; 8 8 # #
&Or6   r   c                   "    e Zd ZdZd Zd Zd Zy)r0   zA
    A constant with an already formatted IR representation.
    c                 V    t        |t              sJ t        j                  | ||       y r   )r   r   r   r   r   s      r$   r   zFormattedConstant.__init__  s$    (C((($X.r6   c                     | j                   S r   r   r   s    r$   r   zFormattedConstant._to_string      }}r6   c                     | j                   S r   r  r   s    r$   r   z FormattedConstant._get_reference  r  r6   N)r   r   r   r   r   r   r   r=   r6   r$   r0   r0     s    /r6   r0   c                   d    e Zd ZdZdZdZd Zd Zd Zd Z	d Z
 ee	e
      Zd	 Zd
 Zed        Zy)
NamedValuez*
    The base class for named values.
    %Tc                     |J t        |t        j                        sJ || _        || _        | j                  |       y r   )r   r   r   parentr,   	_set_name)rC   r  r,   names       r$   r   zNamedValue.__init__  s<    !!!$

+++	tr6   c                 
   g }t        | j                  t        j                        s.|j	                  dj                  | j                                      | j                  |       dj                  |      j                         S )Nz{0} = r   )
r   r,   r   r   appendr.   r/   descrr   rstriprC   r#   s     r$   r   zNamedValue._to_string   sY    $))U^^4JJxt'9'9';<=

3wws|""$$r6   c                     t         r   )NotImplementedErrorr  s     r$   r  zNamedValue.descr'  s    !!r6   c                     | j                   S r   )_namer   s    r$   	_get_namezNamedValue._get_name*  s    zzr6   c                 t    | j                   j                  j                  || j                        }|| _        y )N)deduplicate)r  scoperegisterdeduplicate_namer  rC   r  s     r$   r  zNamedValue._set_name-  s4    {{  ))$6:6K6K * M
r6   c                     | j                   }d|v sd|v r"|j                  dd      j                  dd      }dj                  | j                  |      S )N\"\5c\22z{0}"{1}")r  replacer.   name_prefixr  s     r$   r   zNamedValue._get_reference4  sN    yy4<3$;<<f-55c6BD  !1!1488r6   c                 j    d| j                   j                  d| j                  d| j                  dS )Nr    z
 of type 'z'>r   r   r  r,   r   s    r$   r   zNamedValue.__repr__;  s%    NN##TYY		; 	;r6   c                     | j                   }t        |t        j                        r| j                   j                  }t        |t        j
                        r|S t        dj                  | j                               )NzNot a function: {0})r,   r   r   r   r   FunctionTyper   r.   )rC   r   s     r$   function_typezNamedValue.function_type?  sZ    YYb%++,""Bb%,,-I188CDDr6   N)r   r   r   r   r$  r  r   r   r  r  r  r   r  r   r   r*  r=   r6   r$   r  r    s[     K%"
 Iy)D9; E Er6   r  c                   D     e Zd ZdZ fdZd Zd ZeZd Zd Z	d Z
 xZS )MetaDataStringz[
    A metadata string, i.e. a constant string used as a value in a metadata
    node.
    c                 d    t         t        |   |t        j                         d       || _        y )Nr   r  )superr,  r   r   MetaDataTypestring)rC   r  r1  r   s      r$   r   zMetaDataString.__init__P  s1    nd,V-2-?-?-A24 	- 	6 r6   c                 .    || j                         dfz  }y )N
)r/   r  s     r$   r  zMetaDataString.descrV  s    ""$d++r6   c                 J    dj                  t        | j                              S )Nz!"{0}")r.   r%   r1  r   s    r$   r   zMetaDataString._get_referenceY  s    ~dkk:;;r6   c                 V    t        |t              r| j                  |j                  k(  S yr   )r   r,  r1  rK   s     r$   r   zMetaDataString.__eq__^  s"    e^,;;%,,..r6   c                 &    | j                  |       S r   r   rK   s     r$   r   zMetaDataString.__ne__d  r   r6   c                 ,    t        | j                        S r   )r   r1  r   s    r$   r   zMetaDataString.__hash__g  s    DKK  r6   )r   r   r   r   r   r  r   r   r   r   r   __classcell__r   s   @r$   r,  r,  J  s-    
,<  J&!r6   r,  c                        e Zd ZdZd Zd ZeZy)MetaDataArgumentz
    An argument value to a function taking metadata arguments.
    This can wrap any other kind of LLVM value.

    Do not instantiate directly, Builder.call() will create these
    automatically.
    c                     t        |t              sJ t        |j                  t        j                        rJ t        j                         | _        || _        y r   )r   r   r,   r   r0  wrapped_valuerC   values     r$   r   zMetaDataArgument.__init__t  sD    %'''ejj%*<*<===&&(	"r6   c                 ~    dj                  | j                  j                  | j                  j                               S r   )r.   r=  r,   r/   r   s    r$   r   zMetaDataArgument._get_referencez  s7     2 2 7 7 $ 2 2 @ @ BD 	Dr6   N)r   r   r   r   r   r   r   r=   r6   r$   r;  r;  k  s    #D
  Jr6   r;  c                       e Zd ZdZd Zd Zy)NamedMetaDatazk
    A named metadata node.

    Do not instantiate directly, use Module.add_named_metadata() instead.
    c                      || _         g | _        y r   )r  operands)rC   r  s     r$   r   zNamedMetaData.__init__  s    r6   c                 :    | j                   j                  |       y r   )rD  r  )rC   mds     r$   rR   zNamedMetaData.add  s    R r6   N)r   r   r   r   r   rR   r=   r6   r$   rB  rB    s    !r6   rB  c                   D     e Zd ZdZdZ fdZd Zd Zd Zd Z	d Z
 xZS )	MDValuez
    A metadata node's value, consisting of a sequence of elements ("operands").

    Do not instantiate directly, use Module.add_metadata() instead.
    !c                     t         t        |   |t        j                         |       t        |      | _        |j                  j                  |        y Nr.  )	r/  rH  r   r   r0  tuplerD  metadatar  )rC   r  r   r  r   s       r$   r   zMDValue.__init__  sG    gt%f&+&8&8&:+/ 	& 	1 ft$r6   c                    g }| j                   D ]  }t        |j                  t        j                        rNt        |t
              r|j                  |j                  d       U|j                  |j                                u|j                  dj                  |j                  |j                                       dj                  |      }|dj                  |      dfz  }y )Nr   r   r*   z
!{{ {0} }}r3  )rD  r   r,   r   r0  r   r   r  r/   r.   r   )rC   r#   rD  rE   s       r$   r  zMDValue.descr  s    -- 	OB"''5#5#56b(+0COOF+OOB$4$4$67	 0 0":J:J:L MN	O 99X&##H-t44r6   c                 F    | j                   t        | j                        z   S r   r$  r   r  r   s    r$   r   zMDValue._get_reference      #dii.00r6   c                 V    t        |t              r| j                  |j                  k(  S yr   )r   rH  rD  rK   s     r$   r   zMDValue.__eq__  s"    eW%==ENN22r6   c                 &    | j                  |       S r   r   rK   s     r$   r   zMDValue.__ne__  r   r6   c                 ,    t        | j                        S r   )r   rD  r   s    r$   r   zMDValue.__hash__  s    DMM""r6   r   r   r   r   r$  r   r  r   r   r   r   r8  r9  s   @r$   rH  rH    s-    
 K%51&#r6   rH  c                       e Zd ZdZd Zy)DITokenz
    A debug information enumeration value that should appear bare in
    the emitted metadata.

    Use this to wrap known constants, e.g. the DW_* enumerations.
    c                     || _         y r   )r?  r>  s     r$   r   zDIToken.__init__  s	    
r6   N)r   r   r   r   r   r=   r6   r$   rW  rW    s    r6   rW  c                   D     e Zd ZdZdZ fdZd Zd Zd Zd Z	d Z
 xZS )	DIValuez
    A debug information descriptor, containing key-value pairs.

    Do not instantiate directly, use Module.add_debug_info() instead.
    rI  c                     t         t        |   |t        j                         |       || _        || _        t        |      | _        |j                  j                  |        y rK  )r/  rZ  r   r   r0  is_distinctkindrL  rD  rM  r  )rC   r  r\  r]  rD  r  r   s         r$   r   zDIValue.__init__  sV    gt%f&+&8&8&:+/ 	& 	1 '	ht$r6   c                 *   | j                   r|dz  }g }| j                  D ]  \  }}|d}n|du rd}n|du rd}nt        |t              r|j                  }nvt        |t
              rdj                  t        |            }nKt        |t              rt        |      }n/t        |t              r|j                         }nt        d|      |j                  d	j                  ||              d
j                  |      }|d| j                  d|dfz  }y )N)z	distinct r   TtrueFfalsez"{}"z%invalid operand type for debug info: z{0}: {1}r*   rI  (z)
)r\  rD  r   rW  r?  r   r.   r%   intr  r/   r   r  r   r]  )rC   r#   rD  keyr?  strvalues         r$   r  zDIValue.descr  s   >!C-- 	>JC}!$!%"E7+ ;;E3'!==)>?E3'u:E:. ..0#(!+ , ,OOJ--c8<=%	>& 99X&TYYXu55r6   c                 F    | j                   t        | j                        z   S r   rP  r   s    r$   r   zDIValue._get_reference  rQ  r6   c                     t        |t              rO| j                  |j                  k(  xr4 | j                  |j                  k(  xr | j                  |j                  k(  S yr   )r   rZ  r\  r]  rD  rK   s     r$   r   zDIValue.__eq__  sT    eW%##u'8'88 0		UZZ'0/0 r6   c                 &    | j                  |       S r   r   rK   s     r$   r   zDIValue.__ne__  r   r6   c                 Z    t        | j                  | j                  | j                  f      S r   )r   r\  r]  rD  r   s    r$   r   zDIValue.__hash__  s"    T%%tyy$--@AAr6   rU  r9  s   @r$   rZ  rZ    s.    
 K%641&Br6   rZ  c                   *     e Zd ZdZdZdZ fdZ xZS )GlobalValuez
    A global value.
    @Fc                 d    t        t        | 
  |i | d| _        d| _        d| _        i | _        y Nr   )r/  rj  r   linkagestorage_classsectionrM  )rC   argskwargsr   s      r$   r   zGlobalValue.__init__  s4    k4)4:6:r6   )r   r   r   r   r$  r  r   r8  r9  s   @r$   rj  rj    s     K r6   rj  c                   *     e Zd ZdZd fd	Zd Z xZS )GlobalVariablez
    A global variable.
    c                    t        |t        j                        sJ t        t        |   ||j                  |      |       || _        d | _        d| _	        d| _
        || _        d | _        | j                  j                  |        y )Nr.  F)r   r   r   r/  rt  r   r   
value_typeinitializerunnamed_addrglobal_constantr   alignr  
add_global)rC   modulerD   r  r   r   s        r$   r   zGlobalVariable.__init__  sz    #uzz***nd,VS^^I5N26 	- 	8!$"
t$r6   c                    | j                   rd}nd}| j                  s| j                  dnd}n| j                  }|r|j                  |dz          | j                  r|j                  | j                  dz          | j
                  r|j                  d       | j                  dk7  r*|j                  dj                  | j                               |j                  d	j                  || j                  
             | j                  | j                  j                  | j                  k7  r/t        d| j                  j                  d| j                        |j                  d| j                  j                         z          n9|dvr5|j                  d| j                  t              j                         z          | j                  r|j                  d| j                  d       | j                  |j                  d| j                  fz         | j                  r!|j                  | j!                  d             |j                  d       y )Nr   globalexternalr   r&  zunnamed_addr r   zaddrspace({0:d}) z{kind} {type})r]  r,   zgot initializer of type z for global value type )r  extern_weakz, section "r   z
, align %dT)leading_commar3  )ry  rn  rw  r  ro  rx  r   r.   rv  r,   r   r/   r   rp  rz  rM  _stringify_metadata)rC   r#   r]  rn  s       r$   r  zGlobalVariable.descr&  s   DD||$($4$4$<j"GllGJJw}%JJt))C/0JJ'>>QJJ*11$..AB

?**4??*KL'$$7#'#3#3#8#8$//!K L L JJsT--;;==>77JJsT__Y7EEGGH<<JJT\\;<::!JJ|tzzm34==JJt//d/CD

4r6   )r   )r   r   r   r   r   r  r8  r9  s   @r$   rt  rt    s    
%*r6   rt  c                   >     e Zd ZdZdZd fd	Zd Z fdZd Z xZ	S )AttributeSetzxA set of string attribute.
    Only accept items listed in *_known*.

    Properties:
    * Iterate in sorted order
    r=   c                 x    t         |           t        |t              r|g}|D ]  }| j	                  |        y r   )r/  r   r   r   rR   )rC   rq  r  r   s      r$   r   zAttributeSet.__init__\  s9    dC 6D 	DHHTN	r6   c                     |S r   r=   )rC   r  rD   s      r$   _expandzAttributeSet._expandc  s    r6   c                 |    || j                   vrt        dj                  ||             t        t        |   |      S )Nzunknown attr {!r} for {})_knownr-   r.   r/  r  rR   rC   r  r   s     r$   rR   zAttributeSet.addf  s:    t{{"7>>tTJKK\4,T22r6   c                 ^    t        |       D cg c]  }| j                  ||       c}S c c}w r   )sortedr  )rC   rD   rt   s      r$   _to_listzAttributeSet._to_listk  s%    .4Tl;Q$;;;s   *r=   )
r   r   r   r   r  r   r  rR   r  r8  r9  s   @r$   r  r  S  s#     F3
<r6   r  c                        e Zd Z eg d      Zd	 fd	Z fdZed        Zej                  d        Zed        Z
e
j                  d        Z
 fdZ xZS )
FunctionAttributes) 
argmemonlyalwaysinlinebuiltincold
convergentinaccessiblememonlyinaccessiblemem_or_argmemonly
inlinehint	jumptableminsizenaked	nobuiltinnoduplicatenoimplicitfloatnoinlinenonlazybind	norecurse	noredzonenoreturnnounwindoptnoneoptsizereadnonereadonlyreturns_twicesanitize_addresssanitize_memorysanitize_threadsspsspreg	sspstronguwtablec                 H    d| _         d | _        t        t        |   |       y Nr   )_alignstack_personalityr/  r  r   rC   rq  r   s     r$   r   zFunctionAttributes.__init__z  s#      $06r6   c                 ^    |dk(  rd| v s	|dk(  rd| v rt        d      t        | 	  |       y )Nr  r  z$Can't have alwaysinline and noinline)r-   r/  rR   r  s     r$   rR   zFunctionAttributes.add  s9    ^#
d(:#$(>CDDDr6   c                     | j                   S r   r  r   s    r$   
alignstackzFunctionAttributes.alignstack  s    r6   c                      |dk\  sJ || _         y r  r  r   s     r$   r  zFunctionAttributes.alignstack  s    axxr6   c                     | j                   S r   )r  r   s    r$   personalityzFunctionAttributes.personality  s       r6   c                 :    |t        |t              sJ || _        y r   )r   rj  r  r   s     r$   r  zFunctionAttributes.personality  s    {jk:::r6   c                 F   t         |   |      }| j                  r*|j                  dj	                  | j                               | j
                  rN|j                  dj	                  | j
                  j                  | j
                  j                                      |S )Nzalignstack({0:d})zpersonality {persty} {persfn})perstypersfn)r/  r  r  r  r.   r  r,   r/   )rC   ret_typeattrsr   s      r$   r  zFunctionAttributes._to_list  s     *??LL,33DOODELL8??'',,''557 @ 9 : r6   r  )r   r   r   	frozensetr  r   rR   r   r  setterr  r  r8  r9  s   @r$   r  r  o  s     * +F7
       ! !     r6   r  c                        e Zd ZdZ fdZed        Zed        Zed        ZddZ	ddZ
d Zd	 Zd
 Zd Zed        Z xZS )FunctionzRepresent a LLVM Function but does uses a Module as parent.
    Global Values are stored as a set of dependencies (attribute `depends`).
    c           	         t        |t        j                        sJ t        t        |   ||j                         |       || _        t        j                         | _
        g | _        t               | _        t        |j                  D cg c]  }t!        | |       c}      | _        t#        | |j$                        | _        | j(                  j+                  |        d| _        y c c}w )Nr.  r   )r   r   r   r/  r  r   r   ftyper   	NameScoper  blocksr  
attributesrL  rq  ArgumentReturnValuereturn_typereturn_valuer  r{  calling_convention)rC   r|  r  r  tr   s        r$   r   zFunction.__init__  s    %,,,h&vu/?/?/A&M
%%'
,.$)JJ0  $D!, 0 1	'e.?.?@t$"$	0s   C(c                     | j                   S r   r  r   s    r$   r|  zFunction.module      {{r6   c                      | j                   d   S r  r  r   s    r$   entry_basic_blockzFunction.entry_basic_block  s    {{1~r6   c                     | j                   S r   r  r   s    r$   basic_blockszFunction.basic_blocks  r  r6   c                 V    t        | |      }| j                  j                  |       |S )Nr  r  )Blockr  r  )rC   r  blks      r$   append_basic_blockzFunction.append_basic_block  s%    4d+3
r6   c                 X    t        | |      }| j                  j                  ||       |S )zInsert block before
        r  )r  r  insert)rC   beforer  r  s       r$   insert_basic_blockzFunction.insert_basic_block  s)     4d+63'
r6   c           	      ,   | j                   rdnd}| j                  }dj                  d | j                  D              }| j	                         }| j
                  rAddj                  | j
                  j                  | j                  j                              z   nd}t        | j                        r| j                  j                  rdnd}n| j                  j                  rdnd}| j                  }| j                  }	dj                  d	 |||	|fD              }
| j                         }|rd
j                  |      nd}| j                  rdj                  | j                        nd}d}|j                  |
||||||      }|j!                  |       y)zB
        Describe the prototype ("head") of the function.
        definedeclarer*   c              3   2   K   | ]  }t        |        y wr   r   ).0as     r$   	<genexpr>z+Function.descr_prototype.<locals>.<genexpr>  s     3AQ3s   r&  r   z, ...z...c              3   8   K   | ]  }|st        |        y wr   r  )r  xs     r$   r  z+Function.descr_prototype.<locals>.<genexpr>  s     LQ!#a&Ls   z {}z section "{}"z:{prefix} {name}({args}{vararg}){attrs}{section}{metadata}
)ry   r  rq  varargr  rp  rM  N)r  r  r   rq  r/   r  r  r  r  anyvar_argrn  r  r  r.   rp  r  )rC   r#   stateretrq  r  r  r  rn  cconvry   rM  rp  pt_str	prototypes                  r$   descr_prototypezFunction.descr_prototype  sX    !KKYyy333!!#(, chht77JJ"" $ % %=? 	tyy> $

 2 2WF"jj00UbF,,''L5'5#*FLL++--55<<)2:>,,/((6BNMMd)/ug+3 " 5	 	

9r6   c                 H    | j                   D ]  }|j                  |        y)z7
        Describe of the body of the function.
        N)r  r  )rC   r#   r  s      r$   
descr_bodyzFunction.descr_body  s"     ;; 	CIIcN	r6   c                     | j                  |       | j                  r4|j                  d       | j                  |       |j                  d       y y )Nz{
z}
)r  r  r  r  r  s     r$   r  zFunction.descr  s@    S!;;JJuOOC JJu r6   c                 J    g }| j                  |       dj                  |      S rm  )r  r   r  s     r$   __str__zFunction.__str__  s     

3wws|r6   c                 2    t        | j                        dk(  S r  )r   r  r   s    r$   is_declarationzFunction.is_declaration  s    4;;1$$r6   r   )r   r   r   r   r   r   r|  r  r  r  r  r  r  r  r  r  r8  r9  s   @r$   r  r    s{    %      
4
 % %r6   r  c                   N    e Zd Z ei ddddddddddddd	dd
ddddddddddddddddddddddd      Zd fd	Zd Zed        Zej                  d        Zed        Z
e
j                  d        Z
ed        Zej                  d        Z fdZ xZS )ArgumentAttributesbyrefTbyvalelementtypeimmargFinallocainregnestnoalias	nocapturenofreenonnullnoundefpreallocatedreturnedsignextsret
swiftasync)
swifterror	swiftselfzeroextc                 V    d| _         d| _        d| _        t        t        |   |       y r  )_align_dereferenceable_dereferenceable_or_nullr/  r  r   r  s     r$   r   zArgumentAttributes.__init__  s*     !()% $06r6   c                 d    | j                   j                  |      }|r| d|j                   dS |S )Nra  r+   )r  getr   )rC   r  rD   requires_types       r$   r  zArgumentAttributes._expand!  s3    -V1S[[M++Kr6   c                     | j                   S r   )r  r   s    r$   rz  zArgumentAttributes.align(  r  r6   c                 @    t        |t              r|dk\  sJ || _        y r  )r   rb  r  r   s     r$   rz  zArgumentAttributes.align,  s    #s#q00r6   c                     | j                   S r   )r  r   s    r$   dereferenceablez"ArgumentAttributes.dereferenceable1  s    $$$r6   c                 @    t        |t              r|dk\  sJ || _        y r  )r   rb  r  r   s     r$   r  z"ArgumentAttributes.dereferenceable5  s     #s#q00 #r6   c                     | j                   S r   )r  r   s    r$   dereferenceable_or_nullz*ArgumentAttributes.dereferenceable_or_null:  s    ,,,r6   c                 @    t        |t              r|dk\  sJ || _        y r  )r   rb  r  r   s     r$   r!  z*ArgumentAttributes.dereferenceable_or_null>  s     #s#q00(+%r6   c                 n   t         |   |      }| j                  r*|j                  dj	                  | j                               | j
                  r*|j                  dj	                  | j
                               | j                  r,d}|j                  |j	                  | j                               |S )Nzalign {0:d}zdereferenceable({0:d})zdereferenceable_or_null({0:d}))r/  r  rz  r  r.   r  r!  )rC   rD   r  drefr   s       r$   r  zArgumentAttributes._to_listC  s     %::LL--djj9:LL1889M9MNO''3DLLT%A%ABCr6   r  )r   r   r   r   r  r   r  r   rz  r  r  r!  r  r8  r9  s   @r$   r  r    s      	 		
 	t 	% 	D 	 	 	5 	U 	% 	5 	5 	  	E!" 	5#$ 	%& 	e'( - F27   \\  % % $ $ - - ##, $,	 	r6   r  c                   ,     e Zd Zd fd	Zd Zd Z xZS )_BaseArgumentc                     t        |t        j                        sJ t        t        |   |||       || _        t               | _        y rK  )	r   r   r   r/  r&  r   r  r  r  )rC   r  rD   r  r   s       r$   r   z_BaseArgument.__init__P  s>    #uzz***mT+FCd+C,.r6   c                 j    d| j                   j                  d| j                  d| j                  dS )Nr   r&  z	 of type r   r'  r   s    r$   r   z_BaseArgument.__repr__V  s&    *...*A*A499*.))5 	5r6   c                 :    | j                   j                  |       y r   )r  rR   )rC   attrs     r$   add_attributez_BaseArgument.add_attributeZ  s    D!r6   r  )r   r   r   r   r   r+  r8  r9  s   @r$   r&  r&  O  s    /5"r6   r&  c                       e Zd ZdZd Zy)r  z3
    The specification of a function argument.
    c                    | j                   j                  | j                        }|r:dj                  | j                  dj	                  |      | j                               S dj                  | j                  | j                               S )Nz{0} {1} {2}r&  r   )r  r  r,   r.   r   r/   rC   r  s     r$   r  zArgument.__str__c  sn    ((3 ''		388E?(,(:(:(<> > ##DIIt/A/A/CDDr6   Nr   r   r   r   r  r=   r6   r$   r  r  ^  s    Er6   r  c                       e Zd ZdZd Zy)r  z9
    The specification of a function's return value.
    c                     | j                   j                  | j                        }|r+dj                  dj	                  |      | j                        S t        | j                        S )Nr   r&  )r  r  r,   r.   r   r   r.  s     r$   r  zReturnValue.__str__q  sJ    ((3##CHHUOTYY??tyy>!r6   Nr/  r=   r6   r$   r  r  l  s    "r6   r  c                   f     e Zd ZdZd	 fd	Zed        Zed        Zed        Zd Z	d Z
d Z xZS )
r  a   
    A LLVM IR basic block. A basic block is a sequence of
    instructions whose execution always goes from start to end.  That
    is, a control flow instruction (branch) can only appear as the
    last instruction, and incoming branches can only jump to the first
    instruction.
    c                     t         t        |   |t        j                         |       |j
                  | _        g | _        d | _        y rK  )r/  r  r   r   	LabelTyper  instructions
terminator)rC   r  r  r   s      r$   r   zBlock.__init__  s:    eT#FEOO,=D#I\\
r6   c                     | j                   d uS r   )r6  r   s    r$   is_terminatedzBlock.is_terminated  s    d**r6   c                     | j                   S r   r  r   s    r$   functionzBlock.function  r  r6   c                 .    | j                   j                  S r   )r  r|  r   s    r$   r|  zBlock.module  s    {{!!!r6   c                     |j                  dj                  | j                                      || j                  D cg c]  }dj                  |       c}z  }y c c}w )Nz{0}:
z  {0}
)r  r.   _format_namer5  )rC   r#   instrs      r$   r  zBlock.descr  sI    

8??4#4#4#678T5F5FGE	  'GGGs   Ac                 l   |j                   |j                   k7  rt        d      | j                  j                  |      }| j                  j	                  |       | j                  j                  ||       | j                  j                  D ]%  }|j                  D ]  }|j                  ||        ' y)zReplace an instructionz$new instruction has a different typeN)	r,   r   r5  indexremover  r  r  replace_usage)rC   oldnewposbbr>  s         r$   r#  zBlock.replace  s    88sxxBCC%%c*  %  c*++** 	.B .##C-.	.r6   c                     | j                   }t        j                  |      s3|j                  dd      j                  dd      }dj	                  |      }|S )Nr  r!  r   r"  z"{0}")r  _SIMPLE_IDENTIFIER_REmatchr#  r.   r  s     r$   r=  zBlock._format_name  sK     yy$**40<<f-55c6BD>>$'Dr6   r  )r   r   r   r   r   r   r8  r:  r|  r  r#  r=  r8  r9  s   @r$   r  r  y  sY     + +   " "H
.r6   r  c                   "    e Zd ZdZd Zd Zd Zy)BlockAddressz'
    The address of a basic block.
    c                     t        |t              sJ t        |t              sJ t        j                  d      j                         | _        || _        || _        y )N   )	r   r  r  r   rx   r   r,   r:  basic_block)rC   r:  rN  s      r$   r   zBlockAddress.__init__  sJ    (H---+u---MM!$//1	 &r6   c                 V    dj                  | j                  | j                               S r   r   r   s    r$   r  zBlockAddress.__str__  r   r6   c                     dj                  | j                  j                         | j                  j                               S )Nzblockaddress({0}, {1}))r.   r:  r/   rN  r   s    r$   r/   zBlockAddress.get_reference  s7    '..MM'')**,. 	.r6   N)r   r   r   r   r   r  r/   r=   r6   r$   rK  rK    s    'A.r6   rK  )3r   r8   r1  rer   r   llvmlite.irr   r   llvmlite.ir._utilsr   r   r	   r  mapordascii_lettersdigitsr   compilerH  rv   r%   r?   rF   r   rH   r   r   r   r   r0   r  r,  r;  rB  rH  rW  rZ  rj  rt  setr  r  r  r  r&  r  r  r  rK  r=   r6   r$   <module>rZ     s  
   	 " - -. . #c6#7#789#c6==123#c#EFGH #

#CD  
	



 ! (" JIF JIZ
OF O. . L	GO{3]E GOT  5E5u 5Ep!Z !B {$;U  .!F !)#j )#X	 	:Bj :Bz*m\ ;[ ;|<3 <81 1hY%{ Y%xM M`"J "E} E
"- 
"3J 3l.5 .r6   