o 7fTL@s6dZddlmZddlmZddlmZmZmZm Z m Z m Z m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:GdddZ;dHd d Ze dZ?ee ee@fe e?fZAGdddee?ZBe e e?e e?fZCGddde.eCe?ZDGdddeDe:ZEdKd d!ZF "dLdMd'd(ZGGd)d*d*eDe:ZHdNd,d-ZIGd.d/d/eDe:ZJdKd0d1ZKdOd4d5ZLGd6d7d7eDe:ZMdPd8d9ZNdZOd:ZP ;dQdRdFdGZQd;S)SzData-flow analyses.) annotations)abstractmethod)DictGenericIterableIteratorSetTupleTypeVar) all_values)+Assign AssignMulti BasicBlockBoxBranchCallCallCCast ComparisonOp ControlOpExtendFloatFloatComparisonOpFloatNegFloatOpGetAttr GetElementPtrGoto InitStaticIntegerIntOp KeepAlive LoadAddressLoadErrorValue LoadGlobal LoadLiteralLoadMem LoadStatic MethodCallOp OpVisitorRaiseStandardError RegisterOpReturnSetAttrSetMemTruncateTupleGetTupleSetUnborrowUnbox UnreachableValuec@s$eZdZdZdd d Zdd d ZdS)CFGzyControl-flow graph. Node 0 is always assumed to be the entry point. There must be a non-empty set of exits. succ"dict[BasicBlock, list[BasicBlock]]predexitsset[BasicBlock]returnNonecCs|sJ||_||_||_dSN)r8r:r;)selfr8r:r;rAP/home/ertert/spirit/venv/lib/python3.10/site-packages/mypyc/analysis/dataflow.py__init__?s z CFG.__init__strcCs,t|jddd}d|d|jd|jS)NcSs t|jSr?)intlabel)erArArBKs zCFG.__str__..)keyzexits: z succ: z pred: )sortedr;r8r:)r@r;rArArB__str__Jsz CFG.__str__N)r8r9r:r9r;r<r=r>r=rD)__name__ __module__ __qualname____doc__rCrKrArArArBr78s  r7blockslist[BasicBlock]r=c Csi}i}t}|D];}tdd|jddDrJdt|j}|s+|||g|D] }|jr;||jq0|||<g||<q | D]\}}|D] } || |qOqIt |||S)zCalculate basic block control-flow graph. The result is a dictionary like this: basic block index -> (successors blocks, predecesssor blocks) css|]}t|tVqdSr?) isinstancer).0oprArArB Zs  zget_cfg..Nz-Control-flow ops must be at the end of blocks) setanyopslist terminatortargetsadd error_handlerappenditemsr7) rQsucc_mappred_mapr;blockr8 error_pointprevnxtrFrArArBget_cfgOs.      rhrFrcCs.t|jdkrt|jdtr|jdj}|S)NrW)lenrZrSrrF)rFrArArBget_real_targetzs rkr>cCsd}|rJ|D]}t|jD] \}}|j|t|qqd}t|}|}|t|D]\}}|dks=|j|rC| |q0d}q0|sdSdS)zCleanup the control flow graph. This eliminates obviously dead basic blocks and eliminates blocks that contain nothing but a single jump. There is a lot more that could be done. TFrN) enumerater\r] set_targetrkrhcopyclearr:r`)rQchangedrditgtcfg orig_blocksrArArB cleanup_cfgs  ruTc@s eZdZd ddZd d d Zd S)AnalysisResultbeforeAnalysisDict[T]afterr=r>cCs||_||_dSr?rxrz)r@rxrzrArArBrCs zAnalysisResult.__init__rDcCsd|jd|jdS)Nzbefore: z after:  r{)r@rArArBrKszAnalysisResult.__str__N)rxryrzryr=r>rL)rMrNrOrCrKrArArArBrws rwc@sfeZdZdhddZedidd Zedjd d ZedkddZedlddZdmddZ dnddZ doddZ dpddZ dqd d!Z drd#d$Zdsd&d'Zdtd)d*Zdud,d-Zdvd/d0Zdwd2d3Zdxd5d6Zdyd8d9Zdzd;d<Zd{d>d?Zd|dAdBZd}dDdEZd~dGdHZddJdKZddMdNZddPdQZddSdTZddVdWZddYdZZ dd\d]Z!dd_d`Z"ddbdcZ#ddedfZ$dgS)BaseAnalysisVisitorrUrr= GenAndKill[T]cC ttfSr?rXr@rUrArArB visit_goto zBaseAnalysisVisitor.visit_gotor,cCtr?NotImplementedErrorrrArArBvisit_register_opz%BaseAnalysisVisitor.visit_register_opr cCrr?rrrArArB visit_assignrz BaseAnalysisVisitor.visit_assignr cCrr?rrrArArBvisit_assign_multirz&BaseAnalysisVisitor.visit_assign_multir/cCrr?rrrArArB visit_set_memrz!BaseAnalysisVisitor.visit_set_memrcC ||Sr?rrrArArB visit_call zBaseAnalysisVisitor.visit_callr(cCrr?rrrArArBvisit_method_callrz%BaseAnalysisVisitor.visit_method_callr#cCrr?rrrArArBvisit_load_error_valuerz*BaseAnalysisVisitor.visit_load_error_valuer%cCrr?rrrArArBvisit_load_literalrz&BaseAnalysisVisitor.visit_load_literalrcCrr?rrrArArBvisit_get_attrrz"BaseAnalysisVisitor.visit_get_attrr.cCrr?rrrArArBvisit_set_attrrz"BaseAnalysisVisitor.visit_set_attrr'cCrr?rrrArArBvisit_load_staticrz%BaseAnalysisVisitor.visit_load_staticrcCrr?rrrArArBvisit_init_staticrz%BaseAnalysisVisitor.visit_init_staticr1cCrr?rrrArArBvisit_tuple_getrz#BaseAnalysisVisitor.visit_tuple_getr2cCrr?rrrArArBvisit_tuple_setrz#BaseAnalysisVisitor.visit_tuple_setrcCrr?rrrArArB visit_boxrzBaseAnalysisVisitor.visit_boxr4cCrr?rrrArArB visit_unboxrzBaseAnalysisVisitor.visit_unboxrcCrr?rrrArArB visit_castrzBaseAnalysisVisitor.visit_castr+cCrr?rrrArArBvisit_raise_standard_errorrz.BaseAnalysisVisitor.visit_raise_standard_errorrcCrr?rrrArArB visit_call_crz BaseAnalysisVisitor.visit_call_cr0cCrr?rrrArArBvisit_truncaterz"BaseAnalysisVisitor.visit_truncatercCrr?rrrArArB visit_extendrz BaseAnalysisVisitor.visit_extendr$cCrr?rrrArArBvisit_load_globalrz%BaseAnalysisVisitor.visit_load_globalr cCrr?rrrArArB visit_int_oprz BaseAnalysisVisitor.visit_int_oprcCrr?rrrArArBvisit_float_oprz"BaseAnalysisVisitor.visit_float_oprcCrr?rrrArArBvisit_float_negrz#BaseAnalysisVisitor.visit_float_negrcCrr?rrrArArBvisit_comparison_oprz'BaseAnalysisVisitor.visit_comparison_oprcCrr?rrrArArBvisit_float_comparison_oprz-BaseAnalysisVisitor.visit_float_comparison_opr&cCrr?rrrArArBvisit_load_memrz"BaseAnalysisVisitor.visit_load_memrcCrr?rrrArArBvisit_get_element_ptrrz)BaseAnalysisVisitor.visit_get_element_ptrr"cCrr?rrrArArBvisit_load_address rz&BaseAnalysisVisitor.visit_load_addressr!cCrr?rrrArArBvisit_keep_aliverz$BaseAnalysisVisitor.visit_keep_aliver3cCrr?rrrArArBvisit_unborrowrz"BaseAnalysisVisitor.visit_unborrowN)rUrr=r~)rUr,r=r~)rUr r=r~)rUr r=r~)rUr/r=r~)rUrr=r~)rUr(r=r~)rUr#r=r~)rUr%r=r~)rUrr=r~)rUr.r=r~)rUr'r=r~)rUrr=r~)rUr1r=r~)rUr2r=r~)rUrr=r~)rUr4r=r~)rUrr=r~)rUr+r=r~)rUrr=r~)rUr0r=r~)rUrr=r~)rUr$r=r~)rUr r=r~)rUrr=r~)rUrr=r~)rUrr=r~)rUrr=r~)rUr&r=r~)rUrr=r~)rUr"r=r~)rUr!r=r~)rUr3r=r~)%rMrNrOrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrArArArBr}sL                                r}c@sbeZdZdZd!d"ddZd#d d Zd$ddZd%ddZd&ddZd'ddZ d(ddZ d)ddZ d S)*DefinedVisitoraVisitor for finding defined registers. Note that this only deals with registers and not temporaries, on the assumption that we never access temporaries when they might be undefined. If strict_errors is True, then we regard any use of LoadErrorValue as making a register undefined. Otherwise we only do if `undefines` is set on the error value. This lets us only consider the things we care about during uninitialized variable checking while capturing all possibly undefined things for refcounting. F strict_errorsboolr=r>cC ||_dSr?r)r@rrArArBrC%rzDefinedVisitor.__init__rUrGenAndKill[Value]cCrr?rrrArArB visit_branch(rzDefinedVisitor.visit_branchr-cCrr?rrrArArB visit_return+rzDefinedVisitor.visit_returnr5cCrr?rrrArArBvisit_unreachable.rz DefinedVisitor.visit_unreachabler,cCrr?rrrArArBr1rz DefinedVisitor.visit_register_opr cCs6t|jtr|jjs |jrt|jhfS|jhtfSr?)rSsrcr# undefinesrrXdestrrArArBr4szDefinedVisitor.visit_assignr cCrr?rrrArArBr;s z!DefinedVisitor.visit_assign_multir/cCrr?rrrArArBr?rzDefinedVisitor.visit_set_memNF)rrr=r>rUrr=rrUr-r=rrUr5r=rrUr,r=rrUr r=rrUr r=rrUr/r=r) rMrNrOrPrCrrrrrrrrArArArBrs       rrsinitial_defined set[Value]AnalysisResult[Value]cCst||t|dtdS)zCalculate potentially defined registers at each CFG location. A register is defined if it has a value along some path from the initial location. FrQrs gen_and_killinitialbackwardkind) run_analysisrMAYBE_ANALYSIS)rQrsrrArArBanalyze_maybe_defined_regsCsrFregsIterable[Value]rrc Cs t||t|d|dtt|dS)aICalculate always defined registers at each CFG location. This analysis can work before exception insertion, since it is a sound assumption that registers defined in a block might not be initialized in its error handler. A register is defined if it has a value along all paths from the initial location. rFrQrsrrrruniverse)rr MUST_ANALYSISrX)rQrsrrrrArArBanalyze_must_defined_regsTsrc@s\eZdZdddZd d d Zd!d dZd"ddZd#ddZd$ddZd%ddZ d&ddZ dS)'BorrowedArgumentsVisitorargsrr=r>cCrr?)r)r@rrArArBrCprz!BorrowedArgumentsVisitor.__init__rUrrcCrr?rrrArArBrsrz%BorrowedArgumentsVisitor.visit_branchr-cCrr?rrrArArBrvrz%BorrowedArgumentsVisitor.visit_returnr5cCrr?rrrArArBryrz*BorrowedArgumentsVisitor.visit_unreachabler,cCrr?rrrArArBr|rz*BorrowedArgumentsVisitor.visit_register_opr cCs&|j|jvr t|jhfSttfSr?)rrrXrrArArBrs  z%BorrowedArgumentsVisitor.visit_assignr cCrr?rrrArArBrrz+BorrowedArgumentsVisitor.visit_assign_multir/cCrr?rrrArArBrrz&BorrowedArgumentsVisitor.visit_set_memN)rrr=r>rrrrrrr) rMrNrOrCrrrrrrrrArArArBros       rborrowedc Cst||t||dt|dS)zCalculate arguments that can use references borrowed from the caller. When assigning to an argument, it no longer is borrowed. Fr)rrr)rQrsrrArArBanalyze_borrowed_argumentssrc@ReZdZdddZddd Zdd d ZdddZdddZdddZd ddZ dS)!UndefinedVisitorrUrr=rcCrr?rrrArArBrrzUndefinedVisitor.visit_branchr-cCrr?rrrArArBrrzUndefinedVisitor.visit_returnr5cCrr?rrrArArBrrz"UndefinedVisitor.visit_unreachabler,cCst|js |hfStfSr?)rXis_voidrrArArBrsz"UndefinedVisitor.visit_register_opr cCt|jhfSr?rXrrrArArBrzUndefinedVisitor.visit_assignr cCrr?rrrArArBrrz#UndefinedVisitor.visit_assign_multir/cCrr?rrrArArBrrzUndefinedVisitor.visit_set_memNrrrrrrr rMrNrOrrrrrrrrArArArBrs      rcCs(ttg||}t||t|dtdS)zCalculate potentially undefined registers at each CFG location. A register is undefined if there is some path from initial block where it has an undefined value. Function arguments are assumed to be always defined. Fr)rXr rrr)rQrsrinitial_undefinedrArArBanalyze_undefined_regss rrUr)cCs0t}|D]}t|ttfs||q|Sr?)rXsourcesrSrrr^)rUresultsourcerArArBnon_trivial_sourcess   rc@r)!LivenessVisitorrUrr=rcCt|tfSr?rrXrrArArBrrzLivenessVisitor.visit_branchr-cCs*t|jttfs|jhtfSttfSr?)rSvaluerrrXrrArArBrs zLivenessVisitor.visit_returnr5cCrr?rrrArArBrrz!LivenessVisitor.visit_unreachabler,cCs"t|}|js ||hfS|tfSr?)rrrX)r@rUgenrArArBrs  z!LivenessVisitor.visit_register_opr cCt||jhfSr?rrrrArArBrzLivenessVisitor.visit_assignr cCrr?rrrArArBrrz"LivenessVisitor.visit_assign_multir/cCrr?rrrArArBrrzLivenessVisitor.visit_set_memNrrrrrrrrrArArArBrs      rcCst||ttdtdS)zCalculate live registers at each CFG location. A register is live at a location if it can be read along some CFG path starting from the location. Tr)rrrXr)rQrsrArArBanalyze_live_regssrriNrOpVisitor[GenAndKill[T]]rset[T]rrErr set[T] | NoneAnalysisResult[T]c Cs~i}i}|D]3} t} t} | j} |rtt| } | D]} | |\}}| ||B} | ||B} q| || <| || <qt|}|sG|ddd}t|}i}i}|D]%} |tkrbt|| <t|| <qQ|dusjJdt||| <t||| <qQ|r|j}|j}n|j}|j}|r|}| |||rd}||D]}|durt||}q|tkr|||O}q|||M}q|dusJnt|}|||<|||||B}|||kr||D]}||vr| || |q|||<|si}i}|D]7} | }||}t | j}|rtt|}|D]\}} ||||f<| |\}}|||B}||||f<qq|r:||}}t ||S)aPRun a general set-based data flow analysis. Args: blocks: All basic blocks cfg: Control-flow graph for the code gen_and_kill: Implementation of gen and kill functions for each op initial: Value of analysis for the entry points (for a forward analysis) or the exit points (for a backward analysis) kind: MUST_ANALYSIS or MAYBE_ANALYSIS backward: If False, the analysis is a forward analysis; it's backward otherwise universe: For a must analysis, the set of all possible values. This is the starting value for the work list algorithm, which will narrow this down until reaching a fixed point. For a maybe analysis the iteration always starts from an empty set and this argument is ignored. Return analysis results: (before, after) NrWz,Universe must be defined for a must analysis)rXrZr[reversedacceptrr8r:popremover`r^rlrw) rQrsrrrrr block_gen block_killrdrkillrZrUopgenopkillworklistworksetrxrzrcrbrF new_beforer: new_afterr8 op_beforeop_aftercurops_enumidxrArArBrs                   r)rQrRr=r7)rFrr=r)rQrRr=r>)rQrRrsr7rrr=rr) rQrRrsr7rrrrrrr=r)rQrRrsr7rrr=r)rUr)r=r)rQrRrsr7r=rr?)rQrRrsr7rrrrrrErrrrr=r)RrP __future__rabcrtypingrrrrrr r mypyc.ir.func_irr mypyc.ir.opsr r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7rhrkrurvrE AnalysisDictrw GenAndKillr}rrrrrrrrrrrrrrArArArBs<  $ /  +  i .