o ØÝ2gÔLã@s:dZddlmZddlmZddlmZmZmZm 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:m;Z;Gdd„dƒZdJdd„Z?e dƒZ@ee eeAfe e@fZBGdd„dee@ƒZCe e e@e e@fZDGdd„de.eDe@ƒZEGdd„deEe;ƒZFdKd d!„ZG "dLdMd'd(„ZHGd)d*„d*eEe;ƒZIdNd,d-„ZJGd.d/„d/eEe;ƒZKdKd0d1„ZLdOd4d5„ZMGd6d7„d7eEe;ƒZNdPd8d9„ZOdZPd:ZQ ;dQdRdFdG„ZRd;S)SzData-flow analyses.é)Ú annotations)Úabstractmethod)ÚDictÚGenericÚIterableÚIteratorÚSetÚTupleÚTypeVar)Ú all_values),ÚAssignÚ AssignMultiÚ BasicBlockÚBoxÚBranchÚCallÚCallCÚCastÚ ComparisonOpÚ ControlOpÚExtendÚFloatÚFloatComparisonOpÚFloatNegÚFloatOpÚGetAttrÚ GetElementPtrÚGotoÚ InitStaticÚIntegerÚIntOpÚ KeepAliveÚ LoadAddressÚLoadErrorValueÚ LoadGlobalÚ LoadLiteralÚLoadMemÚ LoadStaticÚ MethodCallÚOpÚ OpVisitorÚ PrimitiveOpÚRaiseStandardErrorÚ RegisterOpÚReturnÚSetAttrÚSetMemÚTruncateÚTupleGetÚTupleSetÚUnborrowÚUnboxÚ UnreachableÚValuec@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]]ÚpredÚexitsúset[BasicBlock]ÚreturnÚNonecCs|sJ‚||_||_||_dS©N)r9r;r<)Úselfr9r;r<©rBúO/home/garg/my-data/venv/lib/python3.10/site-packages/mypyc/analysis/dataflow.pyÚ__init__@s z CFG.__init__ÚstrcCs,t|jdd„d}d|›d|j›d|j›S)NcSs t|jƒSr@)ÚintÚlabel)ÚerBrBrCÚLs zCFG.__str__..)Úkeyzexits: z succ: z pred: )Úsortedr<r9r;)rAr<rBrBrCÚ__str__Ksz CFG.__str__N)r9r:r;r:r<r=r>r?©r>rE)Ú__name__Ú __module__Ú __qualname__Ú__doc__rDrLrBrBrBrCr89s  r8Úblocksúlist[BasicBlock]r>c CsÀi}i}tƒ}|D];}tdd„|jdd…DƒƒrJdƒ‚t|j ¡ƒ}|s+| |¡|g|D] }|jr;| |j¡q0|||<g||<q |  ¡D]\}}|D] } ||  |¡qOqIt |||ƒS)z¡Calculate basic block control-flow graph. The result is a dictionary like this: basic block index -> (successors blocks, predecesssor blocks) css|]}t|tƒVqdSr@)Ú isinstancer)Ú.0ÚoprBrBrCÚ [s€  ÿzget_cfg..Néÿÿÿÿz-Control-flow ops must be at the end of blocks) ÚsetÚanyÚopsÚlistÚ terminatorÚtargetsÚaddÚ error_handlerÚappendÚitemsr8) rRÚsucc_mapÚpred_mapr<Úblockr9Ú error_pointÚprevÚnxtrGrBrBrCÚget_cfgPs.  ÿþ  € ÿ rirGrcCs.t|jƒdkrt|jdtƒr|jdj}|S)NérX)Úlenr[rTrrG)rGrBrBrCÚget_real_target{s rlr?cCs˜d}|rJ|D]}t|j ¡ƒD] \}}|j |t|ƒ¡qqd}t|ƒ}| ¡}| ¡t|ƒD]\}}|dks=|j|rC|  |¡q0d}q0|sdSdS)zÄCleanup 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_targetrlriÚcopyÚclearr;ra)rRÚchangedreÚiÚtgtÚcfgÚ orig_blocksrBrBrCÚ cleanup_cfgsÿ  ñrvÚTc@s eZdZd dd„Zd d d „Zd S)ÚAnalysisResultÚbeforeúAnalysisDict[T]Úafterr>r?cCs||_||_dSr@©ryr{)rAryr{rBrBrCrD¢s zAnalysisResult.__init__rEcCsd|j›d|j›dS)Nzbefore: z after: Ú r|)rArBrBrCrL¦szAnalysisResult.__str__N)ryrzr{rzr>r?rM)rNrOrPrDrLrBrBrBrCrx¡s rxc@speZdZdkdd„Zedldd „ƒZedmd d „ƒZedndd„ƒZedodd„ƒZdpdd„Z dqdd„Z drdd„Z dsdd„Z dtd d!„Z dud#d$„Zdvd&d'„Zdwd)d*„Zdxd,d-„Zdyd/d0„Zdzd2d3„Zd{d5d6„Zd|d8d9„Zd}d;d<„Zd~d>d?„ZddAdB„Zd€dDdE„ZddGdH„Zd‚dJdK„ZdƒdMdN„Zd„dPdQ„Zd…dSdT„Zd†dVdW„Zd‡dYdZ„Z dˆd\d]„Z!d‰d_d`„Z"dŠdbdc„Z#d‹dedf„Z$dŒdhdi„Z%djS)ÚBaseAnalysisVisitorrVrr>ú GenAndKill[T]cCó tƒtƒfSr@©rY©rArVrBrBrCÚ visit_goto®ó zBaseAnalysisVisitor.visit_gotor-cCót‚r@©ÚNotImplementedErrorr‚rBrBrCÚvisit_register_op±óz%BaseAnalysisVisitor.visit_register_opr cCr…r@r†r‚rBrBrCÚ visit_assignµr‰z BaseAnalysisVisitor.visit_assignr cCr…r@r†r‚rBrBrCÚvisit_assign_multi¹r‰z&BaseAnalysisVisitor.visit_assign_multir0cCr…r@r†r‚rBrBrCÚ visit_set_mem½r‰z!BaseAnalysisVisitor.visit_set_memrcCó | |¡Sr@©rˆr‚rBrBrCÚ visit_callÁó zBaseAnalysisVisitor.visit_callr(cCrr@rŽr‚rBrBrCÚvisit_method_callÄrz%BaseAnalysisVisitor.visit_method_callr#cCrr@rŽr‚rBrBrCÚvisit_load_error_valueÇrz*BaseAnalysisVisitor.visit_load_error_valuer%cCrr@rŽr‚rBrBrCÚvisit_load_literalÊrz&BaseAnalysisVisitor.visit_load_literalrcCrr@rŽr‚rBrBrCÚvisit_get_attrÍrz"BaseAnalysisVisitor.visit_get_attrr/cCrr@rŽr‚rBrBrCÚvisit_set_attrÐrz"BaseAnalysisVisitor.visit_set_attrr'cCrr@rŽr‚rBrBrCÚvisit_load_staticÓrz%BaseAnalysisVisitor.visit_load_staticrcCrr@rŽr‚rBrBrCÚvisit_init_staticÖrz%BaseAnalysisVisitor.visit_init_staticr2cCrr@rŽr‚rBrBrCÚvisit_tuple_getÙrz#BaseAnalysisVisitor.visit_tuple_getr3cCrr@rŽr‚rBrBrCÚvisit_tuple_setÜrz#BaseAnalysisVisitor.visit_tuple_setrcCrr@rŽr‚rBrBrCÚ visit_boxßrzBaseAnalysisVisitor.visit_boxr5cCrr@rŽr‚rBrBrCÚ visit_unboxârzBaseAnalysisVisitor.visit_unboxrcCrr@rŽr‚rBrBrCÚ visit_castårzBaseAnalysisVisitor.visit_castr,cCrr@rŽr‚rBrBrCÚvisit_raise_standard_errorèrz.BaseAnalysisVisitor.visit_raise_standard_errorrcCrr@rŽr‚rBrBrCÚ visit_call_cërz BaseAnalysisVisitor.visit_call_cr+cCrr@rŽr‚rBrBrCÚvisit_primitive_opîrz&BaseAnalysisVisitor.visit_primitive_opr1cCrr@rŽr‚rBrBrCÚvisit_truncateñrz"BaseAnalysisVisitor.visit_truncatercCrr@rŽr‚rBrBrCÚ visit_extendôrz BaseAnalysisVisitor.visit_extendr$cCrr@rŽr‚rBrBrCÚvisit_load_global÷rz%BaseAnalysisVisitor.visit_load_globalr cCrr@rŽr‚rBrBrCÚ visit_int_opúrz BaseAnalysisVisitor.visit_int_oprcCrr@rŽr‚rBrBrCÚvisit_float_opýrz"BaseAnalysisVisitor.visit_float_oprcCrr@rŽr‚rBrBrCÚvisit_float_negrz#BaseAnalysisVisitor.visit_float_negrcCrr@rŽr‚rBrBrCÚvisit_comparison_oprz'BaseAnalysisVisitor.visit_comparison_oprcCrr@rŽr‚rBrBrCÚvisit_float_comparison_oprz-BaseAnalysisVisitor.visit_float_comparison_opr&cCrr@rŽr‚rBrBrCÚvisit_load_mem rz"BaseAnalysisVisitor.visit_load_memrcCrr@rŽr‚rBrBrCÚvisit_get_element_ptr rz)BaseAnalysisVisitor.visit_get_element_ptrr"cCrr@rŽr‚rBrBrCÚvisit_load_addressrz&BaseAnalysisVisitor.visit_load_addressr!cCrr@rŽr‚rBrBrCÚvisit_keep_aliverz$BaseAnalysisVisitor.visit_keep_aliver4cCrr@rŽr‚rBrBrCÚvisit_unborrowrz"BaseAnalysisVisitor.visit_unborrowN)rVrr>r)rVr-r>r)rVr r>r)rVr r>r)rVr0r>r)rVrr>r)rVr(r>r)rVr#r>r)rVr%r>r)rVrr>r)rVr/r>r)rVr'r>r)rVrr>r)rVr2r>r)rVr3r>r)rVrr>r)rVr5r>r)rVrr>r)rVr,r>r)rVrr>r)rVr+r>r)rVr1r>r)rVrr>r)rVr$r>r)rVr r>r)rVrr>r)rVrr>r)rVrr>r)rVrr>r)rVr&r>r)rVrr>r)rVr"r>r)rVr!r>r)rVr4r>r)&rNrOrPrƒrrˆrŠr‹rŒrr‘r’r“r”r•r–r—r˜r™ršr›rœrržrŸr r¡r¢r£r¤r¥r¦r§r¨r©rªr«r¬rBrBrBrCr~­sN                                 r~c@sbeZdZdZd!d"dd„Zd#d d „Zd$dd„Zd%dd„Zd&dd„Zd'dd„Z d(dd„Z d)dd„Z 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_errorsÚboolr>r?cCó ||_dSr@©r®)rAr®rBrBrCrD)rzDefinedVisitor.__init__rVrúGenAndKill[Value]cCr€r@rr‚rBrBrCÚ visit_branch,r„zDefinedVisitor.visit_branchr.cCr€r@rr‚rBrBrCÚ visit_return/r„zDefinedVisitor.visit_returnr6cCr€r@rr‚rBrBrCÚvisit_unreachable2r„z DefinedVisitor.visit_unreachabler-cCr€r@rr‚rBrBrCrˆ5r„z DefinedVisitor.visit_register_opr cCs6t|jtƒr|jjs |jrtƒ|jhfS|jhtƒfSr@)rTÚsrcr#Ú undefinesr®rYÚdestr‚rBrBrCrŠ8szDefinedVisitor.visit_assignr cCr€r@rr‚rBrBrCr‹?s z!DefinedVisitor.visit_assign_multir0cCr€r@rr‚rBrBrCrŒCr„zDefinedVisitor.visit_set_memN©F)r®r¯r>r?©rVrr>r²©rVr.r>r²©rVr6r>r²©rVr-r>r²©rVr r>r²©rVr r>r²©rVr0r>r²) rNrOrPrQrDr³r´rµrˆrŠr‹rŒrBrBrBrCr­s       r­rtÚinitial_definedú set[Value]úAnalysisResult[Value]cCst||tƒ|dtdS)zšCalculate potentially defined registers at each CFG location. A register is defined if it has a value along some path from the initial location. F©rRrtÚ gen_and_killÚinitialÚbackwardÚkind)Ú run_analysisr­ÚMAYBE_ANALYSIS)rRrtrÁrBrBrCÚanalyze_maybe_defined_regsGsúrËFÚregsúIterable[Value]r®r¯c 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. r±F©rRrtrÅrÆrÇrÈÚuniverse)rÉr­Ú MUST_ANALYSISrY)rRrtrÁrÌr®rBrBrCÚanalyze_must_defined_regsXsùrÑc@s\eZdZddd„Zd d d „Zd!d d„Zd"dd„Zd#dd„Zd$dd„Zd%dd„Z d&dd„Z dS)'ÚBorrowedArgumentsVisitorÚargsrÂr>r?cCr°r@)rÓ)rArÓrBrBrCrDtrz!BorrowedArgumentsVisitor.__init__rVrr²cCr€r@rr‚rBrBrCr³wr„z%BorrowedArgumentsVisitor.visit_branchr.cCr€r@rr‚rBrBrCr´zr„z%BorrowedArgumentsVisitor.visit_returnr6cCr€r@rr‚rBrBrCrµ}r„z*BorrowedArgumentsVisitor.visit_unreachabler-cCr€r@rr‚rBrBrCrˆ€r„z*BorrowedArgumentsVisitor.visit_register_opr cCs&|j|jvr tƒ|jhfStƒtƒfSr@)r¸rÓrYr‚rBrBrCrŠƒs  z%BorrowedArgumentsVisitor.visit_assignr cCr€r@rr‚rBrBrCr‹ˆr„z+BorrowedArgumentsVisitor.visit_assign_multir0cCr€r@rr‚rBrBrCrŒ‹r„z&BorrowedArgumentsVisitor.visit_set_memN)rÓrÂr>r?rºr»r¼r½r¾r¿rÀ) rNrOrPrDr³r´rµrˆrŠr‹rŒrBrBrBrCrÒss       rÒÚborrowedc Cst||t|ƒ|dt|dS)zˆCalculate arguments that can use references borrowed from the caller. When assigning to an argument, it no longer is borrowed. FrÎ)rÉrÒrÐ)rRrtrÔrBrBrCÚanalyze_borrowed_argumentssùrÕc@óReZdZddd„Zddd „Zdd d „Zddd„Zddd„Zddd„Zd dd„Z dS)!ÚUndefinedVisitorrVrr>r²cCr€r@rr‚rBrBrCr³¢r„zUndefinedVisitor.visit_branchr.cCr€r@rr‚rBrBrCr´¥r„zUndefinedVisitor.visit_returnr6cCr€r@rr‚rBrBrCrµ¨r„z"UndefinedVisitor.visit_unreachabler-cCstƒ|js |hfStƒfSr@)rYÚis_voidr‚rBrBrCrˆ«sz"UndefinedVisitor.visit_register_opr cCótƒ|jhfSr@©rYr¸r‚rBrBrCrŠ®ózUndefinedVisitor.visit_assignr cCrÙr@rÚr‚rBrBrCr‹±rÛz#UndefinedVisitor.visit_assign_multir0cCr€r@rr‚rBrBrCrŒ´r„zUndefinedVisitor.visit_set_memNrºr»r¼r½r¾r¿rÀ© rNrOrPr³r´rµrˆrŠr‹rŒrBrBrBrCrסs      r×cCs(ttg|ƒƒ|}t||tƒ|dtdS)zéCalculate 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Ä)rYr rÉr×rÊ)rRrtrÁÚinitial_undefinedrBrBrCÚanalyze_undefined_regs¸s úrÞrVr)cCs0tƒ}| ¡D]}t|ttfƒs| |¡q|Sr@)rYÚsourcesrTrrr_)rVÚresultÚsourcerBrBrCÚnon_trivial_sourcesÍs   €râc@rÖ)!ÚLivenessVisitorrVrr>r²cCót|ƒtƒfSr@©rârYr‚rBrBrCr³ÖrÛzLivenessVisitor.visit_branchr.cCs*t|jttfƒs|jhtƒfStƒtƒfSr@)rTÚvaluerrrYr‚rBrBrCr´Ùs zLivenessVisitor.visit_returnr6cCr€r@rr‚rBrBrCrµßr„z!LivenessVisitor.visit_unreachabler-cCs"t|ƒ}|js ||hfS|tƒfSr@)rârØrY)rArVÚgenrBrBrCrˆâs  z!LivenessVisitor.visit_register_opr cCót|ƒ|jhfSr@©râr¸r‚rBrBrCrŠéózLivenessVisitor.visit_assignr cCrèr@rér‚rBrBrCr‹ìrêz"LivenessVisitor.visit_assign_multir0cCrär@rår‚rBrBrCrŒïrÛzLivenessVisitor.visit_set_memNrºr»r¼r½r¾r¿rÀrÜrBrBrBrCrãÕs      rãcCst||tƒtƒdtdS)zŸCalculate 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Ä)rÉrãrYrÊ)rRrtrBrBrCÚanalyze_live_regsósúrërjNrÅúOpVisitor[GenAndKill[T]]rÆúset[T]rÈrFrÇrÏú set[T] | NoneúAnalysisResult[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|dusjJdƒ‚t|ƒ|| <t|ƒ|| <qQ|r€|j}|j}n|j}|j}|rô| ¡}|  |¡||rÁd}||D]}|dur¨t||ƒ}q›|tkr³|||O}q›|||M}q›|dusÀJ‚nt|ƒ}|||<|||||B}|||krî||D]}||vrí|  |¡|  |¡qÝ|||<|sˆi}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) NrXz,Universe must be defined for a must analysis)rYr[r\ÚreversedÚacceptrÊr9r;ÚpopÚremoverar_rmrx) rRrtrÅrÆrÈrÇrÏÚ block_genÚ block_killrerçÚkillr[rVÚopgenÚopkillÚworklistÚworksetryr{rdrcrGÚ new_beforer;Ú new_afterr9Ú op_beforeÚop_afterÚcurÚops_enumÚidxrBrBrCrÉs            €ê     ü  rÉ)rRrSr>r8)rGrr>r)rRrSr>r?)rRrSrtr8rÁrÂr>rÃr¹) rRrSrtr8rÁrÂrÌrÍr®r¯r>rÃ)rRrSrtr8rÔrÂr>rÃ)rVr)r>rÂ)rRrSrtr8r>rÃr@)rRrSrtr8rÅrìrÆrírÈrFrÇr¯rÏrîr>rï)SrQÚ __future__rÚabcrÚtypingrrrrrr 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/r0r1r2r3r4r5r6r7r8rirlrvrwrFÚ AnalysisDictrxÚ GenAndKillr~r­rËrÑrÒrÕr×rÞrârãrërÐrÊrÉrBrBrBrCÚs<  $ ¸0  +  l . û     ù