o tBhJ@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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5GdddZ6dHd d Z7dIddZ8dJddZ9e dZ:ee ee;fe e:fZGddde*e>e:Z?Gddde?e5Z@dKd d!ZA "dLdMd'd(ZBGd)d*d*e?e5ZCdNd,d-ZDGd.d/d/e?e5ZEdKd0d1ZFdOd4d5ZGGd6d7d7e?e5ZHdPd8d9ZIdZJd:ZK ;dQdRdFdGZLd;S)SzData-flow analyses.) annotations)abstractmethod)DictGenericIterableIteratorSetTupleTypeVar) all_values)&Assign AssignMulti BasicBlockBoxBranchCallCallCCast ComparisonOp ControlOpExtendGetAttr GetElementPtrGoto InitStaticIntegerIntOp KeepAlive LoadAddressLoadErrorValue LoadGlobal LoadLiteralLoadMem LoadStatic MethodCallOp OpVisitorRaiseStandardError RegisterOpReturnSetAttrSetMemTruncateTupleGetTupleSetUnbox 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)r3r5r6)selfr3r5r6r<n/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/mypyc/analysis/dataflow.py__init__:s z CFG.__init__strcCsJg}|dt|jddd|d|j|d|jd|S)Nz exits: %scSs|jSr:label)er<r<r=GszCFG.__str__..)keyzsucc: %szpred: %s )appendsortedr6r3r5join)r;linesr<r<r=__str__Es  z CFG.__str__N)r3r4r5r4r6r7r8r9r8r?)__name__ __module__ __qualname____doc__r>rJr<r<r<r=r23s  r2blockslist[BasicBlock]r8c 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).0opr<r<r= Ys  zget_cfg..Nz-Control-flow ops must be at the end of blocks) setanyopslist terminatortargetsadd error_handlerrFitemsr2) rPsucc_mappred_mapr6blockr3 error_pointprevnxtrAr<r<r=get_cfgMs.      rfrArcCs.t|jdkrt|jdtr|jdj}|S)NrV)lenrYrRrrAr@r<r<r=get_real_targetys rir9cCsd}|rL|D]}t|jD] \}}|j|t|qqd}t|}|dd}|t|D]\}}|dks?|j|rE||q2d}q2|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. TFNr) enumerater[r\ set_targetrirfclearr5rF)rPchangedrbitgtcfg orig_blocksr<r<r= cleanup_cfgs   rrTc@s eZdZd ddZd d d Zd S)AnalysisResultbeforeAnalysisDict[T]afterr8r9cCs||_||_dSr:rurw)r;rurwr<r<r=r>s zAnalysisResult.__init__r?cCsd|jd|jdS)Nzbefore: z after: rErx)r;r<r<r=rJszAnalysisResult.__str__N)rurvrwrvr8r9rK)rLrMrNr>rJr<r<r<r=rts rtc@s>eZdZd\ddZed]dd Zed^d d Zed_ddZed`ddZdaddZ dbddZ dcddZ ddddZ ded d!Z dfd#d$Zdgd&d'Zdhd)d*Zdid,d-Zdjd/d0Zdkd2d3Zdld5d6Zdmd8d9Zdnd;d<Zdod>d?ZdpdAdBZdqdDdEZdrdGdHZdsdJdKZdtdMdNZdudPdQZdvdSdTZdwdVdWZdxdYdZZ d[S)yBaseAnalysisVisitorrTrr8 GenAndKill[T]cC ttfSr:rWr;rTr<r<r= visit_goto zBaseAnalysisVisitor.visit_gotor(cCtr:NotImplementedErrorr}r<r<r=visit_register_opz%BaseAnalysisVisitor.visit_register_opr cCrr:rr}r<r<r= visit_assignrz BaseAnalysisVisitor.visit_assignr cCrr:rr}r<r<r=visit_assign_multirz&BaseAnalysisVisitor.visit_assign_multir+cCrr:rr}r<r<r= visit_set_memrz!BaseAnalysisVisitor.visit_set_memrcC ||Sr:rr}r<r<r= visit_call zBaseAnalysisVisitor.visit_callr$cCrr:rr}r<r<r=visit_method_callrz%BaseAnalysisVisitor.visit_method_callrcCrr:rr}r<r<r=visit_load_error_valuerz*BaseAnalysisVisitor.visit_load_error_valuer!cCrr:rr}r<r<r=visit_load_literalrz&BaseAnalysisVisitor.visit_load_literalrcCrr:rr}r<r<r=visit_get_attrrz"BaseAnalysisVisitor.visit_get_attrr*cCrr:rr}r<r<r=visit_set_attrrz"BaseAnalysisVisitor.visit_set_attrr#cCrr:rr}r<r<r=visit_load_staticrz%BaseAnalysisVisitor.visit_load_staticrcCrr:rr}r<r<r=visit_init_staticrz%BaseAnalysisVisitor.visit_init_staticr-cCrr:rr}r<r<r=visit_tuple_getrz#BaseAnalysisVisitor.visit_tuple_getr.cCrr:rr}r<r<r=visit_tuple_setrz#BaseAnalysisVisitor.visit_tuple_setrcCrr:rr}r<r<r= visit_boxrzBaseAnalysisVisitor.visit_boxr/cCrr:rr}r<r<r= visit_unboxrzBaseAnalysisVisitor.visit_unboxrcCrr:rr}r<r<r= visit_castrzBaseAnalysisVisitor.visit_castr'cCrr:rr}r<r<r=visit_raise_standard_errorrz.BaseAnalysisVisitor.visit_raise_standard_errorrcCrr:rr}r<r<r= visit_call_crz BaseAnalysisVisitor.visit_call_cr,cCrr:rr}r<r<r=visit_truncaterz"BaseAnalysisVisitor.visit_truncatercCrr:rr}r<r<r= visit_extendrz BaseAnalysisVisitor.visit_extendr cCrr:rr}r<r<r=visit_load_globalrz%BaseAnalysisVisitor.visit_load_globalrcCrr:rr}r<r<r= visit_int_oprz BaseAnalysisVisitor.visit_int_oprcCrr:rr}r<r<r=visit_comparison_oprz'BaseAnalysisVisitor.visit_comparison_opr"cCrr:rr}r<r<r=visit_load_memrz"BaseAnalysisVisitor.visit_load_memrcCrr:rr}r<r<r=visit_get_element_ptrrz)BaseAnalysisVisitor.visit_get_element_ptrrcCrr:rr}r<r<r=visit_load_addressrz&BaseAnalysisVisitor.visit_load_addressrcCrr:rr}r<r<r=visit_keep_aliverz$BaseAnalysisVisitor.visit_keep_aliveN)rTrr8rz)rTr(r8rz)rTr r8rz)rTr r8rz)rTr+r8rz)rTrr8rz)rTr$r8rz)rTrr8rz)rTr!r8rz)rTrr8rz)rTr*r8rz)rTr#r8rz)rTrr8rz)rTr-r8rz)rTr.r8rz)rTrr8rz)rTr/r8rz)rTrr8rz)rTr'r8rz)rTrr8rz)rTr,r8rz)rTrr8rz)rTr r8rz)rTrr8rz)rTrr8rz)rTr"r8rz)rTrr8rz)rTrr8rz)rTrr8rz)!rLrMrNr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr<r<r<r=rysD                            ryc@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_errorsboolr8r9cC ||_dSr:r)r;rr<r<r=r>rzDefinedVisitor.__init__rTrGenAndKill[Value]cCr{r:r|r}r<r<r= visit_branchrzDefinedVisitor.visit_branchr)cCr{r:r|r}r<r<r= visit_returnrzDefinedVisitor.visit_returnr0cCr{r:r|r}r<r<r=visit_unreachable!rz DefinedVisitor.visit_unreachabler(cCr{r:r|r}r<r<r=r$rz DefinedVisitor.visit_register_opr cCs6t|jtr|jjs |jrt|jhfS|jhtfSr:)rRsrcr undefinesrrWdestr}r<r<r=r'szDefinedVisitor.visit_assignr cCr{r:r|r}r<r<r=r.s z!DefinedVisitor.visit_assign_multir+cCr{r:r|r}r<r<r=r2rzDefinedVisitor.visit_set_memNF)rrr8r9rTrr8rrTr)r8rrTr0r8rrTr(r8rrTr r8rrTr r8rrTr+r8r) rLrMrNrOr>rrrrrrrr<r<r<r=rs       rrpinitial_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. FrPrp gen_and_killinitialbackwardkind) run_analysisrMAYBE_ANALYSIS)rPrprr<r<r=analyze_maybe_defined_regs6srFregsIterable[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. rFrPrprrrruniverse)rr MUST_ANALYSISrW)rPrprrrr<r<r=analyze_must_defined_regsGsrc@s\eZdZdddZd d d Zd!d dZd"ddZd#ddZd$ddZd%ddZ d&ddZ dS)'BorrowedArgumentsVisitorargsrr8r9cCrr:)r)r;rr<r<r=r>crz!BorrowedArgumentsVisitor.__init__rTrrcCr{r:r|r}r<r<r=rfrz%BorrowedArgumentsVisitor.visit_branchr)cCr{r:r|r}r<r<r=rirz%BorrowedArgumentsVisitor.visit_returnr0cCr{r:r|r}r<r<r=rlrz*BorrowedArgumentsVisitor.visit_unreachabler(cCr{r:r|r}r<r<r=rorz*BorrowedArgumentsVisitor.visit_register_opr cCs&|j|jvr t|jhfSttfSr:)rrrWr}r<r<r=rrs  z%BorrowedArgumentsVisitor.visit_assignr cCr{r:r|r}r<r<r=rwrz+BorrowedArgumentsVisitor.visit_assign_multir+cCr{r:r|r}r<r<r=rzrz&BorrowedArgumentsVisitor.visit_set_memN)rrr8r9rrrrrrr) rLrMrNr>rrrrrrrr<r<r<r=rbs       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)rPrprr<r<r=analyze_borrowed_arguments~src@ReZdZdddZddd Zdd d ZdddZdddZdddZd ddZ dS)!UndefinedVisitorrTrr8rcCr{r:r|r}r<r<r=rrzUndefinedVisitor.visit_branchr)cCr{r:r|r}r<r<r=rrzUndefinedVisitor.visit_returnr0cCr{r:r|r}r<r<r=rrz"UndefinedVisitor.visit_unreachabler(cCst|js |hfStfSr:)rWis_voidr}r<r<r=rsz"UndefinedVisitor.visit_register_opr cCt|jhfSr:rWrr}r<r<r=rzUndefinedVisitor.visit_assignr cCrr:rr}r<r<r=rrz#UndefinedVisitor.visit_assign_multir+cCr{r:r|r}r<r<r=rrzUndefinedVisitor.visit_set_memNrrrrrrr rLrMrNrrrrrrrr<r<r<r=rs      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)rWr rrr)rPrprinitial_undefinedr<r<r=analyze_undefined_regss rrTr%cCs,t}|D] }t|ts||q|Sr:)rWsourcesrRrr])rTresultsourcer<r<r=non_trivial_sourcess    rc@r)!LivenessVisitorrTrr8rcCt|tfSr:rrWr}r<r<r=rrzLivenessVisitor.visit_branchr)cCs&t|jts |jhtfSttfSr:)rRvaluerrWr}r<r<r=rs  zLivenessVisitor.visit_returnr0cCr{r:r|r}r<r<r=rrz!LivenessVisitor.visit_unreachabler(cCs"t|}|js ||hfS|tfSr:)rrrW)r;rTgenr<r<r=rs  z!LivenessVisitor.visit_register_opr cCt||jhfSr:rrr}r<r<r=rzLivenessVisitor.visit_assignr cCrr:rr}r<r<r=rrz"LivenessVisitor.visit_assign_multir+cCrr:rr}r<r<r=rrzLivenessVisitor.visit_set_memNrrrrrrrrr<r<r<r=rs      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)rrrWr)rPrpr<r<r=analyze_live_regssrrgNrOpVisitor[GenAndKill[T]]rset[T]rintrr 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) NrVz,Universe must be defined for a must analysis)rWrYrZreversedacceptrr3r5popremoverFr]rjrt) rPrprrrrr block_gen block_killrbrkillrYrTopgenopkillworklistworksetrurwrar`rA new_beforer5 new_afterr3 op_beforeop_aftercurops_enumidxr<r<r=rs                   r)rPrQr8r2)rArr8r)rPrQr8r9)rPrQrpr2rrr8rr) rPrQrpr2rrrrrrr8r)rPrQrpr2rrr8r)rTr%r8r)rPrQrpr2r8rr:)rPrQrpr2rrrrrrrrrrr8r)MrO __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/r0r1r2rfrirrrsr AnalysisDictrt GenAndKillryrrrrrrrrrrrrrr<r<r<r=s<  $ *  ,  ] .