U
    ,‰d¬¿  ã                   @   sZ  d Z ddlmZ ddlZddlmZmZmZ ddlm	Z	 ddl
mZmZ ddlmZmZ ddlmZ dd	lmZ e e¡Zd
ZedkrŠendZedhƒZe	G dd„ deƒƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZe	G dd„ deƒƒZ edddddgƒZ!G dd„ deƒZ"edd d!dd"d#gƒZ#d$d%„ Z$d&d'„ Z%G d(d)„ d)eƒZ&G d*d+„ d+eƒZ'dS ),z)
Implement python 3.8+ bytecode analysis
é    )ÚpformatN)Ú
namedtupleÚdefaultdictÚdeque)Útotal_ordering)Ú
UniqueDictÚ	PYVERSION)ÚNEW_BLOCKERSÚCFGraph)ÚLoc)ÚUnsupportedErroré   ©é   é   é   Ú
LOAD_CONSTc                   @   sL   e Zd ZdZeddddddhƒZdd	„ Zd
d„ Zdd„ Zdd„ Z	dd„ Z
dS )Ú	BlockKindz?Kinds of block to make related code safer than just `str`.
    ÚLOOPÚTRYÚEXCEPTÚFINALLYÚWITHÚWITH_FINALLYc                 C   s   || j kst‚|| _d S ©N)Ú_membersÚAssertionErrorÚ_value)ÚselfÚvalue© r    ú7/tmp/pip-unpacked-wheel-eu7e0c37/numba/core/byteflow.pyÚ__init__$   s    zBlockKind.__init__c                 C   s   t t| ƒ| jfƒS r   )ÚhashÚtyper   ©r   r    r    r!   Ú__hash__(   s    zBlockKind.__hash__c                 C   s,   t |tƒr| j|jk S td t|ƒ¡ƒ‚d S ©Nzcannot compare to {!r}©Ú
isinstancer   r   Ú	TypeErrorÚformatr$   ©r   Úotherr    r    r!   Ú__lt__+   s    
zBlockKind.__lt__c                 C   s,   t |tƒr| j|jkS td t|ƒ¡ƒ‚d S r'   r(   r,   r    r    r!   Ú__eq__1   s    
zBlockKind.__eq__c                 C   s   d  | j¡S )NzBlockKind({}))r+   r   r%   r    r    r!   Ú__repr__7   s    zBlockKind.__repr__N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	frozensetr   r"   r&   r.   r/   r0   r    r    r    r!   r      s      ýr   c                   @   s   e Zd Zdd„ Zdd„ ZdS )Ú_lazy_pformatc                 O   s   || _ || _d S r   )ÚargsÚkwargs)r   r7   r8   r    r    r!   r"   <   s    z_lazy_pformat.__init__c                 C   s   t | j| jŽS r   )r   r7   r8   r%   r    r    r!   Ú__str__@   s    z_lazy_pformat.__str__N)r1   r2   r3   r"   r9   r    r    r    r!   r6   ;   s   r6   c                   @   s@   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dS )ÚFlowziData+Control Flow analysis.

    Simulate execution to recover dataflow and controlflow information.
    c                 C   s"   t  d| ¡ ¡ || _tƒ | _d S )Nzbytecode dump:
%s)Ú_loggerÚdebugÚdumpÚ	_bytecoder   Úblock_infos)r   Úbytecoder    r    r!   r"   I   s    zFlow.__init__c                 C   sò  t | jdddd}t| jjjd}|j |¡ tƒ }|jrœt 	d|j¡ |j 
¡ }||jkr4t 	d|j¡ |||j< | |¡ | ¡ rŽqlqv| ¡ rB| ¡ jtkrB|j| ¡ jd | d¡}| |¡ |j}i }||d	 krô||d	  |d
< |d }tdƒttdƒti|d  |d< ||d< |jf d|d i|—Ž qlqv| ¡  |  |¡rv|  |¡ | ¡  qlqvt 	d|j ¡ |j !|¡ | "¡ }	|j #|	¡ q4|  $|j¡ |  %|¡ t&|jdd„ dD ](}t'|ƒ | j(|j< }
t 	d||
¡ qÄdS )aì  Run a trace over the bytecode over all reachable path.

        The trace starts at bytecode offset 0 and gathers stack and control-
        flow information by partially interpreting each bytecode.
        Each ``State`` instance in the trace corresponds to a basic-block.
        The State instances forks when a jump instruction is encountered.
        A newly forked state is then added to the list of pending states.
        The trace ends when there are no more pending states.
        r   r    ©r@   ÚpcÚnstackÚ
blockstack)Údebug_filenamezpending: %sz	stack: %s©rB   r   Úentry_stackÚnpopÚhandlerr   r   ÚkindÚnpushÚextra_blockrB   Úendzend state. edges=%sc                 S   s   | j S r   )Ú
pc_initial)Úxr    r    r!   Ú<lambda>”   ó    zFlow.run.<locals>.<lambda>)Úkeyzblock_infos %s:
%sN))ÚStater>   ÚTraceRunnerZfunc_idÚfilenameÚpendingÚappendr   r;   r<   ÚpopleftÚfinishedÚ_stackrN   ÚdispatchÚhas_terminatedÚhas_active_tryÚget_instÚopnameÚ_NO_RAISE_OPSÚforkÚnextÚget_top_blockÚpop_block_and_aboveÚstack_depthr   Ú_EXCEPT_STACK_OFFSETÚ_FINALLY_POPÚ
advance_pcÚ_is_implicit_new_blockÚ_guard_with_asÚsplit_new_blockÚoutgoing_edgesÚaddÚget_outgoing_statesÚextendÚ
_build_cfgÚ_prune_phisÚsortedÚadapt_state_infosr?   )r   Z
firststateÚrunnerZfirst_encounterÚstateZtryblkrC   r8   rI   Z
out_statesÚsir    r    r!   ÚrunN   sd    

ÿ




ÿ

  þý


zFlow.runc                 C   sd   t ƒ }|D ]}|j}| |¡ q
|D ]"}|jD ]}| |j|jd¡ q.q$| d¡ | ¡  || _d S )Nr   )	r
   rN   Úadd_noderl   Zadd_edgerB   Zset_entry_pointÚprocessÚcfgraph)r   Z
all_statesÚgraphru   ÚbÚedger    r    r!   rp   ˜   s    

zFlow._build_cfgc           	         s   t  d dd¡¡ ‡fdd„}‡ ‡fdd„}‡ fdd	„}‡fd
d„}|ƒ \}‰ t  dt|ƒ¡ |ƒ \}}||ƒ |||ƒ t  d dd¡¡ d S )Nz
Prune PHIsé<   ú-c                     sR   t tƒ} tƒ }ˆ jD ]4}t|jƒ}t|jƒ}| |  ||@ O  < ||O }q| |fS r   )r   ÚsetrY   Ú
_used_regsÚ_phis)Ú	used_phisÚphi_setru   ÚusedZphis©rt   r    r!   Úget_used_phis_per_state¬   s    



z1Flow._prune_phis.<locals>.get_used_phis_per_statec                     sv   i } t tƒ}ˆjD ]:}|j ¡ D ]*\}}|ˆ kr8|| |< ||  ||f¡ q qt dt| ƒ¡ t dt|ƒ¡ | |fS )Nz
defmap: %szphismap: %s)	r   r€   rY   Ú_outgoing_phisÚitemsrm   r;   r<   r6   )ÚdefmapÚphismapru   ÚphiÚrhs©r„   rt   r    r!   Úfind_use_defs·   s    
z'Flow._prune_phis.<locals>.find_use_defsc                    sš   t tƒ}d}tt|  ¡ ƒƒD ]`\}}tt|ƒƒD ].\}}|ˆ kr0|| | O }||  ||f¡ q0|| }||@ r||8 }d}qt dt| ƒ¡ |sq–qdS )znAn iterative dataflow algorithm to find the definition
            (the source) of each PHI node.
            FTzchanging phismap: %sN)	r   r€   rr   Úlistr‰   rm   r;   r<   r6   )r‹   Z	blacklistZchangingrŒ   Zdefsitesr   ru   Z	to_remove)r„   r    r!   Úpropagate_phi_mapÄ   s    z+Flow._prune_phis.<locals>.propagate_phi_mapc                    s¦   i }|   ¡ D ]\}}|D ]}|| ||< qqt dt|ƒ¡ ttƒ}|D ]"}|| D ]\}}||| |< qTqHt dt|ƒ¡ ˆ jD ]}|j ¡  |j 	|| ¡ q‚d S )Nzkeep phismap: %sznew_out: %s)
r‰   r;   r<   r6   r   ÚdictrY   rˆ   ÚclearÚupdate)rƒ   r‹   Zkeepru   Zused_setrŒ   Znew_outr   r†   r    r!   Úapply_changesÚ   s    

z'Flow._prune_phis.<locals>.apply_changeszUsed_phis: %szDONE Prune PHIs)r;   r<   Úcenterr6   )	r   rt   r‡   r   r‘   r•   rƒ   rŠ   r‹   r    rŽ   r!   rq   ¤   s    


zFlow._prune_phisc                 C   s0   |  ¡ }|j| jjkrdS |jtkr(dS dS d S )NTF)r^   Úoffsetr>   Úlabelsr_   r	   ©r   ru   Úinstr    r    r!   ri   ñ   s    
zFlow._is_implicit_new_blockc                 C   s8   |  ¡ }|jdkr4| j|j j}|dkr4d}t|ƒ‚dS )zÞChecks if the next instruction after a SETUP_WITH is something other
        than a POP_TOP, if it is something else it'll be some sort of store
        which is not supported (this corresponds to `with CTXMGR as VAR(S)`).Ú
SETUP_WITHÚPOP_TOPzGThe 'with (context manager) as (variable):' construct is not supported.N)r^   r_   r>   rb   r   )r   ru   Zcurrent_instZnext_opÚmsgr    r    r!   rj   û   s    
zFlow._guard_with_asN)
r1   r2   r3   r4   r"   rw   rp   rq   ri   rj   r    r    r    r!   r:   D   s   JM
r:   c                   @   s†  e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd d!„ Zd"d#„ Zd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd,d-„ Zd.d/„ Zd0d1„ Zd2d3„ Zd4d5„ Zd6d7„ Zd8d9„ Zd:d;„ Z d<d=„ Z!e!Z"e!Z#d>d?„ Z$e$Z%e$Z&d@dA„ Z'dBdC„ Z(dDdE„ Z)dFdG„ Z*dHdI„ Z+dJdK„ Z,dLdM„ Z-dNdO„ Z.dPdQ„ Z/dRdS„ Z0dTdU„ Z1dVdW„ Z2dXdY„ Z3dZd[„ Z4d\d]„ Z5d^d_„ Z6d`da„ Z7dbdc„ Z8ddde„ Z9dfdg„ Z:dhdi„ Z;djdk„ Z<dldm„ Z=dndo„ Z>dpdq„ Z?drds„ Z@dtdu„ ZAdvdw„ ZBdxdy„ ZCdzd{„ ZDd|d}„ ZEd~d„ ZFd€d„ ZGd‚dƒ„ ZHd„d…„ ZId†d‡„ ZJdˆd‰„ ZKdŠd‹„ ZLdŒd„ ZMdŽd„ ZNdd‘„ ZOd’d“„ ZPd”d•„ ZQd–d—„ ZRd˜d™„ ZSdšd›„ ZTdœd„ ZUdždŸ„ ZVd d¡„ ZWd¢d£„ ZXd¤d¥„ ZYeYZZeYZ[eYZ\eYZ]d¦d§„ Z^e^Z_e^Z`e^Zae^Zbe^Zce^Zde^Zee^Zfe^Zge^Zhe^Zie^Zje^Zke^Zle^Zme^Zne^Zoe^Zpe^Zqe^Zre^Zse^Zte^Zue^Zve^Zwe^Zxe^Zye^Zze^Z{e^Z|e^Z}dºd©dª„Z~d«d¬„ Zd­d®„ Z€d¯d°„ Zd±d²„ Z‚d³d´„ Zƒdµd¶„ Z„d·d¸„ Z…d¹S )»rT   zLTrace runner contains the states for the trace and the opcode dispatch.
    c                 C   s   || _ tƒ | _tƒ | _d S r   )rE   r   rV   r€   rY   )r   rE   r    r    r!   r"     s    zTraceRunner.__init__c                 C   s   t | j|ƒS r   )r   rE   )r   Úlinenor    r    r!   Úget_debug_loc  s    zTraceRunner.get_debug_locc                 C   sp   |  ¡ }t d|j|¡ t d|j¡ t| d |j¡d ƒ}|d k	rN|||ƒ nd|j }t||  	|j
¡d‚d S )Nzdispatch pc=%s, inst=%szstack %szop_{}z$Use of unsupported opcode (%s) found©Úloc)r^   r;   r<   Ú_pcrZ   Úgetattrr+   r_   r   rŸ   rž   )r   ru   rš   Úfnr   r    r    r!   r[     s    
zTraceRunner.dispatchc                 C   s   |  |¡ d S r   ©rW   r™   r    r    r!   Úop_NOP  s    zTraceRunner.op_NOPc                 C   sZ   |j dkr"d}t||  |j¡d‚| ¡ }| ¡ }| ¡ }|j||||d | |¡ dS )aF  
        FORMAT_VALUE(flags): flags argument specifies format spec which is
        not supported yet. Currently, we just call str() on the value.
        Pops a value from stack and pushes results back.
        Required for supporting f-strings.
        https://docs.python.org/3/library/dis.html#opcode-FORMAT_VALUE
        r   z*format spec in f-strings not supported yetr    )r   ÚresÚstrvarN)Úargr   rŸ   rž   ÚpopÚ	make_temprW   Úpush)r   ru   rš   r   r   r¨   r§   r    r    r!   Úop_FORMAT_VALUE"  s    
zTraceRunner.op_FORMAT_VALUEc                    st   |j }tt‡ fdd„t|ƒD ƒƒƒ}|dkr8ˆ  ¡ g}n‡ fdd„t|d ƒD ƒ}ˆ j|||d ˆ  |d ¡ dS )	zú
        BUILD_STRING(count): Concatenates count strings from the stack and
        pushes the resulting string onto the stack.
        Required for supporting f-strings.
        https://docs.python.org/3/library/dis.html#opcode-BUILD_STRING
        c                    s   g | ]}ˆ   ¡ ‘qS r    ©rª   ©Ú.0Ú_©ru   r    r!   Ú
<listcomp>;  s     z/TraceRunner.op_BUILD_STRING.<locals>.<listcomp>r   c                    s   g | ]}ˆ   ¡ ‘qS r    ©r«   r¯   r²   r    r!   r³   @  s     r   )ÚstringsÚtmpséÿÿÿÿN©r©   r   ÚreversedÚranger«   rW   r¬   )r   ru   rš   Úcountrµ   r¶   r    r²   r!   Úop_BUILD_STRING3  s    zTraceRunner.op_BUILD_STRINGc                 C   s   |  ¡  d S r   r®   r™   r    r    r!   Ú
op_POP_TOPD  s    zTraceRunner.op_POP_TOPc                 C   s$   |  ¡ }|j||d | |¡ d S ©N©r§   ©r«   rW   r¬   ©r   ru   rš   r§   r    r    r!   Úop_LOAD_GLOBALG  s    zTraceRunner.op_LOAD_GLOBALc                 C   s$   |  ¡ }|j||d | |¡ d S r¾   rÀ   rÁ   r    r    r!   Úop_LOAD_DEREFL  s    zTraceRunner.op_LOAD_DEREFc                 C   s&   |  d¡}| |¡ |j||d d S )NÚconstr¿   )r«   r¬   rW   rÁ   r    r    r!   Úop_LOAD_CONSTQ  s    

zTraceRunner.op_LOAD_CONSTc                 C   s.   |  ¡ }| ¡ }|j|||d | |¡ d S )N)Úitemr§   ©rª   r«   rW   r¬   )r   ru   rš   rÆ   r§   r    r    r!   Úop_LOAD_ATTRV  s    zTraceRunner.op_LOAD_ATTRc                 C   s0   |  |¡}| |¡}|j||d | |¡ d S r¾   )Úget_varnamer«   rW   r¬   )r   ru   rš   Únamer§   r    r    r!   Úop_LOAD_FAST\  s    

zTraceRunner.op_LOAD_FASTc                 C   s   |  |¡ d S r   r¥   r™   r    r    r!   Úop_DELETE_FASTb  s    zTraceRunner.op_DELETE_FASTc                 C   s   |  ¡ }|j||d d S )N)Útarget©rª   rW   )r   ru   rš   rÍ   r    r    r!   Úop_DELETE_ATTRe  s    zTraceRunner.op_DELETE_ATTRc                 C   s$   |  ¡ }|  ¡ }|j|||d d S )N)rÍ   r   rÎ   )r   ru   rš   rÍ   r   r    r    r!   Úop_STORE_ATTRi  s    zTraceRunner.op_STORE_ATTRc                 C   s   |  ¡ }|j||d d S ©N)r   rÎ   ©r   ru   rš   r   r    r    r!   Úop_STORE_DEREFn  s    zTraceRunner.op_STORE_DEREFc                 C   s   |  ¡ }|j||d d S rÑ   rÎ   rÒ   r    r    r!   Úop_STORE_FASTr  s    zTraceRunner.op_STORE_FASTc           	   	   C   sV   |  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }| ¡ }|j|||||||d | |¡ dS )z"
        TOS = TOS1[TOS:]
        )ÚbaseÚstartr§   ÚslicevarÚindexvarÚnonevarNrÇ   ©	r   ru   rš   ÚtosÚtos1r§   r×   rØ   rÙ   r    r    r!   Ú
op_SLICE_1v  s     ù	zTraceRunner.op_SLICE_1c           	   	   C   sV   |  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }| ¡ }|j|||||||d | |¡ dS )z"
        TOS = TOS1[:TOS]
        )rÕ   Ústopr§   r×   rØ   rÙ   NrÇ   rÚ   r    r    r!   Ú
op_SLICE_2‹  s     ù	zTraceRunner.op_SLICE_2c           	   	   C   sV   |  ¡ }|  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }|j|||||||d | |¡ dS )z&
        TOS = TOS2[TOS1:TOS]
        )rÕ   rÖ   rÞ   r§   r×   rØ   NrÇ   )	r   ru   rš   rÛ   rÜ   Útos2r§   r×   rØ   r    r    r!   Ú
op_SLICE_3   s     ù	zTraceRunner.op_SLICE_3c                 C   sB   |  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }|j||||||d dS )z
        TOS[:] = TOS1
        )rÕ   r   r×   rØ   rÙ   N©rª   r«   rW   )r   ru   rš   rÛ   r   r×   rØ   rÙ   r    r    r!   Úop_STORE_SLICE_0µ  s    úzTraceRunner.op_STORE_SLICE_0c           	   	   C   sL   |  ¡ }|  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }|j|||||||d dS )z#
        TOS1[TOS:] = TOS2
        )rÕ   rÖ   r×   r   rØ   rÙ   Nrâ   ©	r   ru   rš   rÛ   rÜ   r   r×   rØ   rÙ   r    r    r!   Úop_STORE_SLICE_1Ç  s    ùzTraceRunner.op_STORE_SLICE_1c           	   	   C   sL   |  ¡ }|  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }|j|||||||d dS )z#
        TOS1[:TOS] = TOS2
        )rÕ   rÞ   r   r×   rØ   rÙ   Nrâ   rä   r    r    r!   Úop_STORE_SLICE_2Û  s    ùzTraceRunner.op_STORE_SLICE_2c           	   	   C   sL   |  ¡ }|  ¡ }|  ¡ }|  ¡ }| ¡ }| ¡ }|j|||||||d dS )z'
        TOS2[TOS1:TOS] = TOS3
        )rÕ   rÖ   rÞ   r   r×   rØ   Nrâ   )	r   ru   rš   rÛ   rÜ   rà   r   r×   rØ   r    r    r!   Úop_STORE_SLICE_3ï  s    ùzTraceRunner.op_STORE_SLICE_3c                 C   s8   |  ¡ }| ¡ }| ¡ }| ¡ }|j|||||d dS )z
        del TOS[:]
        )rÕ   r×   rØ   rÙ   Nrâ   )r   ru   rš   rÛ   r×   rØ   rÙ   r    r    r!   Úop_DELETE_SLICE_0  s       þzTraceRunner.op_DELETE_SLICE_0c                 C   sB   |  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }|j||||||d dS )z 
        del TOS1[TOS:]
        )rÕ   rÖ   r×   rØ   rÙ   Nrâ   ©r   ru   rš   rÛ   rÜ   r×   rØ   rÙ   r    r    r!   Úop_DELETE_SLICE_1  s    úzTraceRunner.op_DELETE_SLICE_1c                 C   sB   |  ¡ }|  ¡ }| ¡ }| ¡ }| ¡ }|j||||||d dS )z 
        del TOS1[:TOS]
        )rÕ   rÞ   r×   rØ   rÙ   Nrâ   ré   r    r    r!   Úop_DELETE_SLICE_2"  s    úzTraceRunner.op_DELETE_SLICE_2c                 C   sB   |  ¡ }|  ¡ }|  ¡ }| ¡ }| ¡ }|j||||||d dS )z$
        del TOS2[TOS1:TOS]
        )rÕ   rÖ   rÞ   r×   rØ   Nrâ   )r   ru   rš   rÛ   rÜ   rà   r×   rØ   r    r    r!   Úop_DELETE_SLICE_34  s        þzTraceRunner.op_DELETE_SLICE_3c                 C   s–   |j }|dkr,| ¡ }| ¡ }|}|}d}n6|dkrZ| ¡ }| ¡ }| ¡ }	|	}|}|}ntdƒ‚| ¡ }
| ¡ }|j||||||
d | |¡ dS )z<
        slice(TOS1, TOS) or slice(TOS2, TOS1, TOS)
        é   Nr   Zunreachable)rÖ   rÞ   Ústepr§   r×   )r©   rª   Ú	Exceptionr«   rW   r¬   )r   ru   rš   ZargcrÛ   rÜ   rÖ   rÞ   rî   rà   r×   r§   r    r    r!   Úop_BUILD_SLICEB  s4         ÿzTraceRunner.op_BUILD_SLICEc                 C   sH   |  ¡ }|j||d | ¡ }|j}|j|d ||krD|j|d d S )N©ÚpredrF   )rª   rW   Úget_jump_targetrb   ra   )r   ru   rš   rò   Ztarget_instZ	next_instr    r    r!   Ú_op_POP_JUMP_IF]  s    zTraceRunner._op_POP_JUMP_IFc                 C   s:   |  ¡ }|j||d |j|jdd |j| ¡ d d S )Nrñ   r   ©rB   rH   rF   )Úget_tosrW   ra   rb   ró   )r   ru   rš   rò   r    r    r!   Ú_op_JUMP_IF_OR_POPl  s    zTraceRunner._op_JUMP_IF_OR_POPc                 C   s   |  |¡ |j| ¡ d d S ©NrF   ©rW   ra   ró   r™   r    r    r!   Úop_JUMP_FORWARDu  s    
zTraceRunner.op_JUMP_FORWARDc                 C   s   |  |¡ |j| ¡ d d S rø   rù   r™   r    r    r!   Úop_JUMP_ABSOLUTEy  s    
zTraceRunner.op_JUMP_ABSOLUTEc                 C   s4   |  d¡d }|j||d | ¡  |j|d d S )Nr   rM   )rM   rF   )rc   rW   Ú	pop_blockra   )r   ru   rš   rM   r    r    r!   Úop_BREAK_LOOP}  s    zTraceRunner.op_BREAK_LOOPc                 C   s$   |j || ¡ | ¡ d | ¡  d S )N)ÚretvalZcastval)rW   rª   r«   Ú	terminater™   r    r    r!   Úop_RETURN_VALUE„  s    zTraceRunner.op_RETURN_VALUEc                 C   s.   |  ¡ }| ¡ }|j|||d | |¡ d S ©N)r   r§   rÇ   ©r   ru   rš   Úvalr§   r    r    r!   Úop_YIELD_VALUEˆ  s    zTraceRunner.op_YIELD_VALUEc                 C   s~   t | d¡d k	| d¡d k	gƒ}|jdkrHd }|rdtd|  |j¡d‚n|jdkr\| ¡ }ntdƒ‚|j||d | 	¡  d S )	Nr   r   r   z4The re-raising of an exception is not yet supported.r    r   z)Multiple argument raise is not supported.©Úexc)
Úanyrc   r©   r   rŸ   rž   rª   Ú
ValueErrorrW   rÿ   )r   ru   rš   Zin_exc_blockr  r    r    r!   Úop_RAISE_VARARGSŽ  s     þ

þ

zTraceRunner.op_RAISE_VARARGSc                 C   s@   g }t tƒD ] }| ¡ }| |¡ | |¡ q|j||d d S )N)Útemps)rº   rf   r«   rW   r¬   )r   ru   rš   r
  ÚiÚtmpr    r    r!   Úop_BEGIN_FINALLY¡  s    
zTraceRunner.op_BEGIN_FINALLYc                 C   s   |  ¡ }| |d ¡ d S )NrG   )rü   Úreset_stack©r   ru   rš   Úblkr    r    r!   Úop_END_FINALLY©  s    zTraceRunner.op_END_FINALLYc                 C   s&   |j dkr"d}t||  |j¡d‚d S )Nr   zGUnsupported use of a bytecode related to try..finally or a with-contextr    )r©   r   rŸ   rž   )r   ru   rš   r   r    r    r!   Úop_POP_FINALLY­  s    
zTraceRunner.op_POP_FINALLYc                 C   s   d S r   r    r™   r    r    r!   Úop_CALL_FINALLY´  s    zTraceRunner.op_CALL_FINALLYc                 C   s   |  |¡ d S r   r¥   r™   r    r    r!   Úop_WITH_CLEANUP_START·  s    z!TraceRunner.op_WITH_CLEANUP_STARTc                 C   s   |  |¡ d S r   r¥   r™   r    r    r!   Úop_WITH_CLEANUP_FINISH»  s    z"TraceRunner.op_WITH_CLEANUP_FINISHc                 C   s   |  |jd| ¡ d¡ d S )Nr   ©rJ   rM   )Ú
push_blockÚ
make_blockró   r™   r    r    r!   Úop_SETUP_LOOP¿  s    þÿzTraceRunner.op_SETUP_LOOPc                 C   sŠ   |  ¡ }| ¡ }|jdd}|j|||d tdk rL| |jd| ¡ d¡ | |¡ | |¡ | |jd| ¡ d¡ |j|j	d d S )	NZsetup_with_exitfn)Úprefix)ÚcontextmanagerÚexitfn)r   é	   r   r  r   rF   )
rª   r«   rW   r   r  r  ró   r¬   ra   rb   )r   ru   rš   ÚcmÚyieldedr  r    r    r!   Úop_SETUP_WITHÈ  s(    þÿ

þÿzTraceRunner.op_SETUP_WITHc                 C   s0   |j |d dd}|j||j d|d|dd d S )NF)rJ   rM   r  r   )rJ   rM   r  rI   )rB   rL   )r  ra   )r   rJ   ru   rb   rM   Zhandler_blockr    r    r!   Ú
_setup_tryä  s    ýüþzTraceRunner._setup_tryc                 C   s&   |  |¡ | jd||j| ¡ d d S )Nr   ©rb   rM   ©rW   r!  rb   ró   r™   r    r    r!   Úop_SETUP_EXCEPTö  s    
   ÿzTraceRunner.op_SETUP_EXCEPTc                 C   s&   |  |¡ | jd||j| ¡ d d S )Nr   r"  r#  r™   r    r    r!   Úop_SETUP_FINALLYý  s    
   ÿzTraceRunner.op_SETUP_FINALLYc                 C   sh   |  ¡ }|d tdƒtdƒhkr>td |d ¡|  |j¡d‚| ¡  | ¡  | ¡  |j|jd d S )NrJ   r   r   z&POP_EXCEPT got an unexpected block: {}r    rF   )	rü   r   r   r+   rŸ   rž   rª   ra   rb   r  r    r    r!   Úop_POP_EXCEPT  s    
þzTraceRunner.op_POP_EXCEPTc                 C   sX   |  ¡ }|d tdƒkr(|j|dd n|d tdƒkrF|j|dd |j|jd d S )NrJ   r   Útry)rJ   r   ÚwithrF   )rü   r   rW   ra   rb   r  r    r    r!   Úop_POP_BLOCK  s    zTraceRunner.op_POP_BLOCKc                 C   s8   |  ¡ }|  ¡ }| ¡ }|j||||d | |¡ d S )N)ÚindexrÍ   r§   rÇ   )r   ru   rš   r*  rÍ   r§   r    r    r!   Úop_BINARY_SUBSCR  s
    zTraceRunner.op_BINARY_SUBSCRc                 C   s.   |  ¡ }|  ¡ }|  ¡ }|j||||d d S )N)rÍ   r*  r   rÎ   )r   ru   rš   r*  rÍ   r   r    r    r!   Úop_STORE_SUBSCR  s    zTraceRunner.op_STORE_SUBSCRc                 C   s$   |  ¡ }|  ¡ }|j|||d d S )N)rÍ   r*  rÎ   )r   ru   rš   r*  rÍ   r    r    r!   Úop_DELETE_SUBSCR%  s    zTraceRunner.op_DELETE_SUBSCRc                    sT   |j }tt‡ fdd„t|ƒD ƒƒƒ}ˆ  ¡ }ˆ  ¡ }ˆ j||||d ˆ  |¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   ,  s     z0TraceRunner.op_CALL_FUNCTION.<locals>.<listcomp>)Úfuncr7   r§   )r©   r   r¹   rº   rª   r«   rW   r¬   )r   ru   rš   Únargr7   r.  r§   r    r²   r!   Úop_CALL_FUNCTION*  s    zTraceRunner.op_CALL_FUNCTIONc                    s^   |j }ˆ  ¡ }tt‡ fdd„t|ƒD ƒƒƒ}ˆ  ¡ }ˆ  ¡ }ˆ j|||||d ˆ  |¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   6  s     z3TraceRunner.op_CALL_FUNCTION_KW.<locals>.<listcomp>)r.  r7   Únamesr§   )r©   rª   r   r¹   rº   r«   rW   r¬   )r   ru   rš   r/  r1  r7   r.  r§   r    r²   r!   Úop_CALL_FUNCTION_KW3  s    zTraceRunner.op_CALL_FUNCTION_KWc                 C   sp   |j d@ rtdkrd}t|ƒ‚|j d@ r2| ¡ }nd }| ¡ }| ¡ }| ¡ }|j|||||d | |¡ d S )Nr   )r   é
   z,CALL_FUNCTION_EX with **kwargs not supported)r.  ÚvarargÚvarkwargr§   )r©   r   r   rª   r«   rW   r¬   )r   ru   rš   Úerrmsgr5  r4  r.  r§   r    r    r!   Úop_CALL_FUNCTION_EX=  s    

zTraceRunner.op_CALL_FUNCTION_EXc                    sp   ‡ fdd„t |ƒD ƒ}| ¡  ‡ fdd„t |ƒD ƒ}ˆ j|||d |D ]}ˆ  |¡ qH|D ]}ˆ  |¡ q\d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   L  s     z)TraceRunner._dup_topx.<locals>.<listcomp>c                    s   g | ]}ˆ   ¡ ‘qS r    r´   r¯   r²   r    r!   r³   P  s     )ÚorigÚduped)rº   ÚreverserW   r¬   )r   ru   rš   r»   r8  r9  r  r    r²   r!   Ú	_dup_topxK  s    zTraceRunner._dup_topxc                 C   s6   |j }d|  krdks$n tdƒ‚|  |||¡ d S )Nr   é   zInvalid DUP_TOPX count)r©   r   r;  )r   ru   rš   r»   r    r    r!   Úop_DUP_TOPXW  s    zTraceRunner.op_DUP_TOPXc                 C   s   | j ||dd d S )Nr   ©r»   ©r;  r™   r    r    r!   Ú
op_DUP_TOP\  s    zTraceRunner.op_DUP_TOPc                 C   s   | j ||dd d S )Nrí   r>  r?  r™   r    r    r!   Úop_DUP_TOP_TWO_  s    zTraceRunner.op_DUP_TOP_TWOc                 C   s(   |  ¡ }|  ¡ }| |¡ | |¡ d S r   ©rª   r¬   )r   ru   rš   ÚfirstÚsecondr    r    r!   Ú
op_ROT_TWOb  s    
zTraceRunner.op_ROT_TWOc                 C   s:   |  ¡ }|  ¡ }|  ¡ }| |¡ | |¡ | |¡ d S r   rB  )r   ru   rš   rC  rD  Úthirdr    r    r!   Úop_ROT_THREEh  s    

zTraceRunner.op_ROT_THREEc                 C   sL   |  ¡ }|  ¡ }|  ¡ }|  ¡ }| |¡ | |¡ | |¡ | |¡ d S r   rB  )r   ru   rš   rC  rD  rF  Zforthr    r    r!   Úop_ROT_FOURp  s    


zTraceRunner.op_ROT_FOURc                    sZ   |j }ˆ  ¡ }‡ fdd„t|ƒD ƒ}ˆ  ¡ }ˆ j||||d t|ƒD ]}ˆ  |¡ qFd S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r´   r¯   r²   r    r!   r³   }  s     z2TraceRunner.op_UNPACK_SEQUENCE.<locals>.<listcomp>)ÚiterableÚstoresÚtupleobj)r©   rª   rº   r«   rW   r¹   r¬   )r   ru   rš   r»   rI  rJ  rK  Ústr    r²   r!   Úop_UNPACK_SEQUENCEz  s    zTraceRunner.op_UNPACK_SEQUENCEc                    sJ   |j }tt‡ fdd„t|ƒD ƒƒƒ}ˆ  ¡ }ˆ j|||d ˆ  |¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   …  s     z.TraceRunner.op_BUILD_TUPLE.<locals>.<listcomp>©r‰   r§   r¸   )r   ru   rš   r»   r‰   Útupr    r²   r!   Úop_BUILD_TUPLEƒ  s
    zTraceRunner.op_BUILD_TUPLEc                    s|   t t‡ fdd„t|jƒD ƒƒƒ}‡ fdd„tt|ƒd ƒD ƒ}t|ƒdk}|rXˆ  ¡ g}ˆ j||||d ˆ  |d ¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   Œ  s     z3TraceRunner._build_tuple_unpack.<locals>.<listcomp>c                    s   g | ]}ˆ   ¡ ‘qS r    r´   r¯   r²   r    r!   r³     s     r   )Útuplesr
  Ú	is_assignr·   )r   r¹   rº   r©   Úlenr«   rW   r¬   )r   ru   rš   rQ  r
  rR  r    r²   r!   Ú_build_tuple_unpackŠ  s     
zTraceRunner._build_tuple_unpackc                 C   s   |   ||¡ d S r   ©rT  r™   r    r    r!   Úop_BUILD_TUPLE_UNPACK_WITH_CALL™  s    z+TraceRunner.op_BUILD_TUPLE_UNPACK_WITH_CALLc                 C   s   |   ||¡ d S r   rU  r™   r    r    r!   Úop_BUILD_TUPLE_UNPACK  s    z!TraceRunner.op_BUILD_TUPLE_UNPACKc                 C   s.   |  ¡ }| ¡ }|j|||d | |¡ d S )N)Ú
const_listr§   rÇ   )r   ru   rš   rÛ   r§   r    r    r!   Úop_LIST_TO_TUPLE   s    zTraceRunner.op_LIST_TO_TUPLEc                    sj   ˆ   ¡ }tt‡ fdd„t|jƒD ƒƒƒ}‡ fdd„t|jƒD ƒ}ˆ  ¡ }ˆ j|||||d ˆ  |¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   ª  s     z6TraceRunner.op_BUILD_CONST_KEY_MAP.<locals>.<listcomp>c                    s   g | ]}ˆ   ¡ ‘qS r    r´   r¯   r²   r    r!   r³   «  s     )ÚkeysÚkeytmpsÚvaluesr§   )rª   r   r¹   rº   r©   r«   rW   r¬   )r   ru   rš   rZ  Úvalsr[  r§   r    r²   r!   Úop_BUILD_CONST_KEY_MAP¨  s     z"TraceRunner.op_BUILD_CONST_KEY_MAPc                    sJ   |j }tt‡ fdd„t|ƒD ƒƒƒ}ˆ  ¡ }ˆ j|||d ˆ  |¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   ²  s     z-TraceRunner.op_BUILD_LIST.<locals>.<listcomp>rN  r¸   )r   ru   rš   r»   r‰   Úlstr    r²   r!   Úop_BUILD_LIST°  s
    zTraceRunner.op_BUILD_LISTc                 C   s@   |  ¡ }|j}| |¡}| ¡ }| ¡ }|j|||||d d S )N)rÍ   r   Ú	appendvarr§   ©rª   r©   Úpeekr«   rW   )r   ru   rš   r   r*  rÍ   ra  r§   r    r    r!   Úop_LIST_APPEND·  s    
ÿzTraceRunner.op_LIST_APPENDc                 C   s@   |  ¡ }|j}| |¡}| ¡ }| ¡ }|j|||||d d S )N)rÍ   r   Ú	extendvarr§   rb  )r   ru   rš   r   r*  rÍ   re  r§   r    r    r!   Úop_LIST_EXTENDÀ  s    
ÿzTraceRunner.op_LIST_EXTENDc           	      C   sj   |  ¡ }|j}g }t|ƒD ]$}| ¡ | ¡  }}| ||f¡ q|j||d d d… ||d | |¡ d S )Nr·   )r‰   Úsizer§   )r«   r©   rº   rª   rW   r¬   )	r   ru   rš   Údctr»   r‰   r  ÚvÚkr    r    r!   Úop_BUILD_MAPÉ  s    zTraceRunner.op_BUILD_MAPc                 C   sf   |  ¡ }|  ¡ }tdk r ||fn||f\}}|j}| |¡}| ¡ }	| ¡ }
|j|||||	|
d d S )Nr   )rÍ   rR   r   Ú
setitemvarr§   )rª   r   r©   rc  r«   rW   )r   ru   rš   ZTOSZTOS1rR   r   r*  rÍ   rl  r§   r    r    r!   Ú
op_MAP_ADDÔ  s    
 ÿzTraceRunner.op_MAP_ADDc                    sJ   |j }tt‡ fdd„t|ƒD ƒƒƒ}ˆ  ¡ }ˆ j|||d ˆ  |¡ d S )Nc                    s   g | ]}ˆ   ¡ ‘qS r    r®   r¯   r²   r    r!   r³   å  s     z,TraceRunner.op_BUILD_SET.<locals>.<listcomp>rN  r¸   )r   ru   rš   r»   r‰   r§   r    r²   r!   Úop_BUILD_SETâ  s
    zTraceRunner.op_BUILD_SETc                 C   s@   |  ¡ }|j}| |¡}| ¡ }| ¡ }|j|||||d d S ©N)rÍ   r   Ú	updatevarr§   rb  ©r   ru   rš   r   r*  rÍ   rp  r§   r    r    r!   Úop_SET_UPDATEê  s    
ÿzTraceRunner.op_SET_UPDATEc                 C   s@   |  ¡ }|j}| |¡}| ¡ }| ¡ }|j|||||d d S ro  rb  rq  r    r    r!   Úop_DICT_UPDATEó  s    
ÿzTraceRunner.op_DICT_UPDATEc                 C   s.   |  ¡ }| ¡ }|j|||d | |¡ d S r  rÇ   )r   ru   rš   r   r§   r    r    r!   Úop_GET_ITERü  s    zTraceRunner.op_GET_ITERc                 C   sf   |  ¡ }| ¡ }| ¡ }| ¡ }|j|||||d | |¡ | ¡ }|j|dd |j|jd d S )N)ÚiteratorÚpairÚindvalrò   rí   rõ   rF   )rö   r«   rW   r¬   ró   ra   rb   )r   ru   rš   ru  rv  rw  rò   rM   r    r    r!   Úop_FOR_ITER  s    ÿ
zTraceRunner.op_FOR_ITERc                 C   s   dS )a(  Pops TOS. If TOS was not None, raises an exception. The kind
        operand corresponds to the type of generator or coroutine and
        determines the error message. The legal kinds are 0 for generator,
        1 for coroutine, and 2 for async generator.

        New in version 3.10.
        Nr    r™   r    r    r!   Úop_GEN_START  s    	zTraceRunner.op_GEN_STARTc                 C   s.   |  ¡ }| ¡ }|j|||d | |¡ d S r  rÇ   r  r    r    r!   Ú_unaryop  s    zTraceRunner._unaryopc                 C   s8   |  ¡ }|  ¡ }| ¡ }|j||||d | |¡ d S )N)Úlhsr   r§   rÇ   )r   ru   rš   r   r{  r§   r    r    r!   Ú	_binaryop$  s
    zTraceRunner._binaryopFc              
   C   sT  |  ¡ }|  ¡ }d  } } }}	tdk rØ|jd@ }
|jd? d@ }|jd? d@ }|rZ|  ¡ }|dkrj|  ¡ }|dkrªg }t|ƒD ]"}|  ¡ }|  ¡ }| ||f¡ q~t|ƒ}|
rÖg }	t|
ƒD ]}|	 |  ¡ ¡ qºt|	ƒ}	nL|jd@ rê|  ¡ }|jd@ rü|  ¡ }|jd@ r|  ¡ }|jd	@ r$|  ¡ }	| ¡ }|j|||||||	|d
 | |¡ d S )N)r   r   éÿ   r   é   iÿ  r   é   rí   r   )rÊ   ÚcodeÚclosureÚannotationsÚ
kwdefaultsÚdefaultsr§   )rª   r   r©   rº   rW   Útupler«   r¬   )r   ru   rš   ÚMAKE_CLOSURErÊ   r€  r  r‚  rƒ  r„  Znum_posdefaultsZnum_kwdefaultsZnum_annotationsr  ri  rj  r§   r    r    r!   Úop_MAKE_FUNCTIONO  sV    



ø
zTraceRunner.op_MAKE_FUNCTIONc                 C   s   | j ||dd d S )NT)r†  )r‡  r™   r    r    r!   Úop_MAKE_CLOSURE}  s    zTraceRunner.op_MAKE_CLOSUREc                 C   s$   |  ¡ }|j||d | |¡ d S r¾   rÀ   rÁ   r    r    r!   Úop_LOAD_CLOSURE€  s    zTraceRunner.op_LOAD_CLOSUREc                 C   s&   |  d¡}|j||d | |¡ d S )NZassertion_errorr¿   rÀ   rÁ   r    r    r!   Úop_LOAD_ASSERTION_ERROR…  s    
z#TraceRunner.op_LOAD_ASSERTION_ERRORc                 C   sN   |  d¡}| ¡ }| ¡ }|j||||d |j|jd |j| ¡ d d S )NÚ	predicate)rò   rÛ   rÜ   rF   )r«   rª   rW   ra   rb   ró   )r   ru   rš   rò   rÛ   rÜ   r    r    r!   Úop_JUMP_IF_NOT_EXC_MATCHŠ  s    
z$TraceRunner.op_JUMP_IF_NOT_EXC_MATCHc                 C   s"   |  ¡ }|j||d | ¡  d S )Nr  )rª   rW   rÿ   )r   ru   rš   r  r    r    r!   Ú
op_RERAISE”  s    zTraceRunner.op_RERAISEc                 C   s   |   ||¡ d S r   )rÈ   r™   r    r    r!   Úop_LOAD_METHOD  s    zTraceRunner.op_LOAD_METHODc                 C   s   |   ||¡ d S r   )r0  r™   r    r    r!   Úop_CALL_METHOD   s    zTraceRunner.op_CALL_METHODN)F)†r1   r2   r3   r4   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ê   rë   rì   rð   rô   Zop_POP_JUMP_IF_TRUEZop_POP_JUMP_IF_FALSEr÷   Zop_JUMP_IF_FALSE_OR_POPZop_JUMP_IF_TRUE_OR_POPrú   rû   rý   r   r  r	  r  r  r  r  r  r  r  r   r!  r$  r%  r&  r)  r+  r,  r-  r0  r2  r7  r;  r=  r@  rA  rE  rG  rH  rM  rP  rT  rV  rW  rY  r^  r`  rd  rf  rk  rm  rn  rr  rs  rt  rx  ry  rz  Zop_UNARY_NEGATIVEZop_UNARY_POSITIVEZop_UNARY_NOTZop_UNARY_INVERTr|  Zop_COMPARE_OPZop_IS_OPZop_CONTAINS_OPZop_INPLACE_ADDZop_INPLACE_SUBTRACTZop_INPLACE_MULTIPLYZop_INPLACE_DIVIDEZop_INPLACE_TRUE_DIVIDEZop_INPLACE_FLOOR_DIVIDEZop_INPLACE_MODULOZop_INPLACE_POWERZop_INPLACE_MATRIX_MULTIPLYZop_INPLACE_LSHIFTZop_INPLACE_RSHIFTZop_INPLACE_ANDZop_INPLACE_ORZop_INPLACE_XORZop_BINARY_ADDZop_BINARY_SUBTRACTZop_BINARY_MULTIPLYZop_BINARY_DIVIDEZop_BINARY_TRUE_DIVIDEZop_BINARY_FLOOR_DIVIDEZop_BINARY_MODULOZop_BINARY_POWERZop_BINARY_MATRIX_MULTIPLYZop_BINARY_LSHIFTZop_BINARY_RSHIFTZop_BINARY_ANDZop_BINARY_ORZop_BINARY_XORr‡  rˆ  r‰  rŠ  rŒ  r  rŽ  r  r    r    r    r!   rT   	  s  		

					
.
	rT   c                   @   sF  e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Z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d„ Zdd„ Zdd„ Zd d!„ ZdLd#d$„Zd%d&„ Zd'd(„ Zd)d*„ Zd+d,„ Zd-d.„ Zd/d0„ Zd1d2„ ZdMd5d6„Zd7d8„ Zd9d:„ Zd;d<„ Z d=d>„ Z!d?d@„ Z"dAdB„ Z#dNdDdE„Z$dFdG„ Z%dHdI„ Z&dJdK„ Z'd4S )OrS   zState of the trace
    c                 C   s   || _ || _|| _|| _g | _t|ƒ| _t|ƒ| _g | _	g | _
g | _d| _i | _tƒ | _tƒ | _t|ƒD ]"}|  d¡}|| j|< |  |¡ qhdS )aG  
        Parameters
        ----------
        bytecode : numba.bytecode.ByteCode
            function bytecode
        pc : int
            program counter
        nstack : int
            stackdepth at entry
        blockstack : Sequence[Dict]
            A sequence of dictionary denoting entries on the blockstack.
        FrŒ   N)r>   Ú_pc_initialr¢   Ú_nstack_initialrZ   r…  Ú_blockstack_initialr   Ú_blockstackÚ_temp_registersÚ_instsÚ	_outedgesÚ_terminatedr‚   r   rˆ   r€   r   rº   r«   r¬   )r   r@   rB   rC   rD   r  rŒ   r    r    r!   r"   ¨  s$    



zState.__init__c                 C   s   d  | j| j¡S )Nz&State(pc_initial={} nstack_initial={}))r+   r  r‘  r%   r    r    r!   r0   È  s     ÿzState.__repr__c                 C   s   | j | jfS r   )r  r‘  r%   r    r    r!   Úget_identityÍ  s    zState.get_identityc                 C   s   t |  ¡ ƒS r   )r#   r˜  r%   r    r    r!   r&   Ð  s    zState.__hash__c                 C   s   |   ¡ |  ¡ k S r   ©r˜  r,   r    r    r!   r.   Ó  s    zState.__lt__c                 C   s   |   ¡ |  ¡ kS r   r™  r,   r    r    r!   r/   Ö  s    zState.__eq__c                 C   s   | j S )z]The starting bytecode offset of this State.
        The PC given to the constructor.
        )r  r%   r    r    r!   rN   Ù  s    zState.pc_initialc                 C   s   | j S )ziThe list of instructions information as a 2-tuple of
        ``(pc : int, register_map : Dict)``
        )r•  r%   r    r    r!   Úinstructionsà  s    zState.instructionsc                 C   s   | j S )zaThe list of outgoing edges.

        Returns
        -------
        edges : List[State]
        ©r–  r%   r    r    r!   rl   ç  s    zState.outgoing_edgesc                 C   s   | j S )z‹The dictionary of outgoing phi nodes.

        The keys are the name of the PHI nodes.
        The values are the outgoing states.
        )rˆ   r%   r    r    r!   Úoutgoing_phisñ  s    zState.outgoing_phisc                 C   s   | j S )z6A copy of the initial state of the blockstack
        )r’  r%   r    r    r!   Úblockstack_initialú  s    zState.blockstack_initialc                 C   s
   t | jƒS )zYThe current size of the stack

        Returns
        -------
        res : int
        )rS  rZ   r%   r    r    r!   re      s    zState.stack_depthc                 C   s,   t | jƒD ]}|d tdƒkr
|  S q
dS )z&Find the initial *try* block.
        rJ   r   N)r¹   r’  r   )r   r  r    r    r!   Úfind_initial_try_block
  s    zState.find_initial_try_blockc                 C   s   | j S r   ©r—  r%   r    r    r!   r\     s    zState.has_terminatedc                 C   s   | j | j S r   )r>   r¢   r%   r    r    r!   r^     s    zState.get_instc                 C   s   |   ¡ }|j| _d S r   )r^   rb   r¢   ©r   rš   r    r    r!   rh     s    zState.advance_pcÚ c                 C   sR   |s*dj || j|  ¡ j ¡ t| jƒd}ndj || jt| jƒd}| j |¡ |S )Nz"${prefix}{offset}{opname}.{tempct})r  r—   r_   Útempctz${prefix}{offset}.{tempct})r  r—   r¢  )r+   r¢   r^   r_   ÚlowerrS  r”  rW   )r   r  rÊ   r    r    r!   r«     s    üýzState.make_tempc                 K   s0   | j  |j|f¡ |  jtt| ¡ ƒƒO  _dS )zAppend new instN)r•  rW   r—   r   r€   Ú_flatten_inst_regsr\  )r   rš   r8   r    r    r!   rW   -  s    zState.appendc                 C   s
   |   d¡S )Nr   )rc  r%   r    r    r!   rö   2  s    zState.get_tosc                 C   s   | j |  S )z-Return the k'th element on the stack
        ©rZ   )r   rj  r    r    r!   rc  5  s    z
State.peekc                 C   s   | j  |¡ dS )zPush to stackN)rZ   rW   )r   rÆ   r    r    r!   r¬   :  s    z
State.pushc                 C   s
   | j  ¡ S )zPop the stack)rZ   rª   r%   r    r    r!   rª   >  s    z	State.popc                 C   s   d|kst ‚| j |¡ dS )z#Push a block to blockstack
        re   N)r   r“  rW   )r   Zsynblkr    r    r!   r  B  s    zState.push_blockc                 C   s$   | j d|… | j |d…  | _ }|S )zVReset the stack to the given stack depth.
        Returning the popped items.
        Nr¥  )r   ÚdepthÚpoppedr    r    r!   r  H  s     zState.reset_stackTNc                 C   s>   t |ƒ|t| jƒdœ}|r*t| jƒ|d< nd|d< ||d< |S )zMake a new block
        )rJ   rM   rG   re   NrI   )r   rS  rZ   )r   rJ   rM   r  rI   Údr    r    r!   r  O  s    ýzState.make_blockc                 C   s   | j  ¡ }|  |d ¡ |S )z)Pop a block and unwind the stack
        re   )r“  rª   r  ©r   r|   r    r    r!   rü   ^  s    
zState.pop_blockc                 C   s@   | j  |¡}d|  kr&t| j ƒk s,n t‚| j d|… | _ dS )zcFind *blk* in the blockstack and remove it and all blocks above it
        from the stack.
        r   N)r“  r*  rS  r   )r   r  Úidxr    r    r!   rd   e  s     zState.pop_block_and_abovec                 C   s0   t |ƒ}t| jƒD ]}|d |kr|  S qdS )z1Find the first block that matches *kind*
        rJ   N)r   r¹   r“  )r   rJ   Úbsr    r    r!   rc   m  s    zState.get_top_blockc                 C   s   |   d¡dk	S )zGReturns a boolean indicating if the top-block is a *try* block
        r   N)rc   r%   r    r    r!   r]   u  s    zState.has_active_tryc                 C   s   | j j|j S )z4Get referenced variable name from the oparg
        )r>   Úco_varnamesr©   r   r    r    r!   rÉ   z  s    zState.get_varnamec                 C   s
   d| _ dS )z!Mark block as terminated
        TNrŸ  r%   r    r    r!   rÿ     s    zState.terminater   c           	      C   s¸   t | jƒ}|rHd|  kr(t| jƒks.n t‚t| jƒ| }|d|… }|rtd|ksXt‚t|ƒD ]}| |  ¡ ¡ q`t | jƒ}|rŒ| |¡ | j t	|t
|ƒ|t
|ƒd¡ |  ¡  dS )zFork the state
        r   N)rB   ÚstackrK   rD   )r   rZ   rS  r   rº   rW   r«   r“  r–  ÚEdger…  rÿ   )	r   rB   rH   rK   rL   r­  rC   r  rD   r    r    r!   ra   „  s&    
 

  þz
State.forkc                 C   s   | j | jd dS )zSplit the state
        rF   N)ra   r¢   r%   r    r    r!   rk   ›  s    zState.split_new_blockc                 C   sh   | j r
t‚g }| jD ]N}t| j|jt|jƒ|jd}| 	|¡ |j
 ¡ D ]\}}|j| | j |< qHq|S )z+Get states for each outgoing edges
        rA   )rˆ   r   r–  rS   r>   rB   rS  r­  rD   rW   r‚   r‰   )r   Úretr}   ru   rŒ   r  r    r    r!   rn      s    


 ÿ
zState.get_outgoing_statesc                 C   s   dd„ | j D ƒS )z–
        Returns
        -------
        Dict[int, int]
            where keys are the PC
            values are the edge-pushed stack values
        c                 S   s&   i | ]}|j t|j|j d … ƒ“qS r   )rB   r…  r­  rK   )r°   r}   r    r    r!   Ú
<dictcomp>¸  s   ÿ z1State.get_outgoing_edgepushed.<locals>.<dictcomp>r›  r%   r    r    r!   Úget_outgoing_edgepushed¯  s    	ÿzState.get_outgoing_edgepushed)r¡  )TN)r   r   N)(r1   r2   r3   r4   r"   r0   r˜  r&   r.   r/   ÚpropertyrN   rš  rl   rœ  r  re   rž  r\   r^   rh   r«   rW   rö   rc  r¬   rª   r  r  r  rü   rd   rc   r]   rÉ   rÿ   ra   rk   rn   r±  r    r    r    r!   rS   ¤  sT    


	


	


rS   r®  rB   r­  rD   rK   c                   @   s$   e Zd ZdZdd„ Zedd„ ƒZdS )ÚAdaptDFAz<Adapt Flow to the old DFA class expected by Interpreter
    c                 C   s
   || _ d S r   )Ú_flow)r   Úflowr    r    r!   r"   Â  s    zAdaptDFA.__init__c                 C   s   | j jS r   )r´  r?   r%   r    r    r!   ÚinfosÅ  s    zAdaptDFA.infosN)r1   r2   r3   r4   r"   r²  r¶  r    r    r    r!   r³  ¿  s   r³  ÚAdaptBlockInfoÚinstsrœ  Úactive_try_blockÚoutgoing_edgepushedc                 C   s$   t t| jƒ| j| j|  ¡ |  ¡ dS )N)r¸  rœ  rD   r¹  rº  )r·  r…  rš  rœ  r  rž  r±  r²   r    r    r!   rs   Ñ  s    ûrs   c                 c   sB   | D ]8}t |tƒr|V  qt |ttfƒrt|ƒD ]
}|V  q0qdS )z<Flatten an iterable of registers used in an instruction
    N)r)   Ústrr…  r   r¤  )rI  rÆ   rO   r    r    r!   r¤  Û  s    
r¤  c                   @   sL   e Zd ZdZdd„ Zedd„ ƒZedd„ ƒZedd	„ ƒZd
d„ Z	dd„ Z
dS )ÚAdaptCFAz<Adapt Flow to the old CFA class expected by Interpreter
    c                 C   s‚   || _ i | _|j ¡ D ]\}}t||ƒ| j|< q| j j ¡ }|j}| ¡ }tƒ }| j 	¡ D ]}| 
|¡rZ| |¡ qZ|| | _d S r   )r´  Ú_blocksr?   r‰   ÚAdaptCFBlockrz   Úbackboner€   ÚblocksrZ  Zin_loopsrm   Ú	_backbone)r   rµ  r—   Ú	blockinfor¿  r{   Zinloopblocksr|   r    r    r!   r"   é  s    
zAdaptCFA.__init__c                 C   s   | j jS r   )r´  rz   r%   r    r    r!   r{   ü  s    zAdaptCFA.graphc                 C   s   | j S r   )rÁ  r%   r    r    r!   r¿     s    zAdaptCFA.backbonec                 C   s   | j S r   )r½  r%   r    r    r!   rÀ    s    zAdaptCFA.blocksc                 c   s    t | jƒD ]}| j| V  q
d S r   )rr   rÀ  r©  r    r    r!   Úiterliveblocks  s    zAdaptCFA.iterliveblocksc                 C   s   | j j ¡  d S r   )r´  rz   r=   r%   r    r    r!   r=     s    zAdaptCFA.dumpN)r1   r2   r3   r4   r"   r²  r{   r¿  rÀ  rÃ  r=   r    r    r    r!   r¼  æ  s   


r¼  c                   @   s   e Zd Zdd„ ZdS )r¾  c                 C   s    || _ tdd„ |jD ƒƒ| _d S )Nc                 s   s   | ]\}}|V  qd S r   r    )r°   r  r±   r    r    r!   Ú	<genexpr>  s     z(AdaptCFBlock.__init__.<locals>.<genexpr>)r—   r…  r¸  Úbody)r   rÂ  r—   r    r    r!   r"     s    zAdaptCFBlock.__init__N)r1   r2   r3   r"   r    r    r    r!   r¾    s   r¾  )(r4   Úpprintr   ÚloggingÚcollectionsr   r   r   Ú	functoolsr   Znumba.core.utilsr   r   Znumba.core.controlflowr	   r
   Znumba.core.irr   Znumba.core.errorsr   Ú	getLoggerr1   r;   rf   rg   r5   r`   Úobjectr   r6   r:   rT   rS   r®  r³  r·  rs   r¤  r¼  r¾  r    r    r    r!   Ú<module>   sV   
ÿ 	 F       "  ÿþ
*