o @a l@sdZddlmZddlmZmZmZddlmZddl m Z ddl m Z m Z mZddlmZddlmZdd lmZdd lmZdd lZdd lmZdd lmZdd lZeZ Gd dde!Z"ddZ#e$D]Z%e#e%qgGdddeZ&Gddde&Z'd S)z' Aliases gather aliasing informations. )GlobalDeclarations) IntrinsicClass UnboundValue)ModuleAnalysis)PythranSyntaxError) functionsmethodsMODULES)Unparser)demangleN)isnumdeepcopy)productcs<eZdZdZedZdZiZfddZefddZ Z S) ContainerOfz Represents a container of something We just know that if indexed by the integer value `index', we get `containee' nanindex containeecsBt|t|f}|tjvrtt||}|tj|<tj|SN)tupleitemsrcachesuper__new__)clsargskwargskeyZnew_obj __class__:/usr/lib/python3/dist-packages/pythran/analyses/aliases.pyr#s    zContainerOf.__new__cCs||_||_dSrr)selfrrr"r"r#__init__,s zContainerOf.__init__) __name__ __module__ __qualname____doc__floatZ UnknownIndex __slots__rrr% __classcell__r"r"r r#rs  rcCsH|D]}t|trt|qt|ft|<t|tr!t|jqdS)z: Recursively save default aliases for pythonic functions. N)values isinstancedictsave_intrinsic_alias frozensetIntrinsicAliasesrZfields)modulevr"r"r#r01s     r0cseZdZdZdZfddZed:ddZdd Zed d Z d:d d Z ddZ ddZ e Z e ZddZddZddZddZddZddZe ZddZd d!Zd"d#Zd$d%Zd&d'ZeZd(d)Zd*d+ZeZeZd,d-Z d.d/Z!d0d1Z"d2d3Z#d4d5Z$d6d7Z%d8d9Z&Z'S);Aliasesz Gather aliasing informations across nodes As a result, each node from the module is associated to a set of node or Intrinsic to which it *may* alias to. @cs,t|_d|_tjtt|t dSr) r/resultaliasesrrclearrr5r%rr$r r"r#r%Js zAliases.__init__Nc Csdd}t|tr,|D]\}}|dust||r)td||tt||q dSt|ttfr>ttt||dSdS)NcSst}t|||Sr)ioStringIOr getvaluestrip)noutputr"r"r#ppRs  zAliases.dump..ppz{} => {}) r.r/rprintformatsortedmapr1set)r7filterrAkr4r"r"r#dumpPs z Aliases.dumpcCsthSr)rr:r"r"r#get_unbound_value_set^zAliases.get_unbound_value_setcCszt|tjrtt|j|jSt|tjr2t|j}t |j }||vr.t d ||j ||St|tjr;|jS|S)Nz*Unsupported attribute '{}' for this object)r.astNamer getr id Attributeattrr5 access_pathvaluerrC FunctionDefname)nodeZattr_keyZ value_dictr"r"r#rRas     zAliases.access_pathcCs0|durt|tr |h}n|}||j|<|Sr)r.rrJr7)r$rVr-r"r"r#addts   z Aliases.addcs"|tjfdd|jDS)af Resulting node may alias to either operands: >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return a or b') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.BoolOp) (a or b) => ['a', 'b'] Note that a literal does not create any alias >>> module = ast.parse('def foo(a, b): return a or 0') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.BoolOp) (a or 0) => ['', 'a'] cg|]}|qSr"visit.0r?r:r"r# z(Aliases.visit_BoolOp..)rWrFunionr-r$rVr"r:r# visit_BoolOp}s"zAliases.visit_BoolOpcCs||||S)a[ Resulting node does not alias to anything >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a): return -a') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.UnaryOp) (- a) => [''] ) generic_visitrWr`r"r"r# visit_UnaryOps zAliases.visit_UnaryOpcs8|jfdd|j|jfD}|tj|S)ag Resulting node alias to either branch >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b, c): return a if c else b') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.IfExp) (a if c else b) => ['a', 'b'] crXr"rYr[r:r"r#r]r^z'Aliases.visit_IfExp..)rZtestbodyorelserWrFr_)r$rVZrecr"r:r# visit_IfExps zAliases.visit_IfExpcCsZ|jr%t}t|j|jD]\}}||||}|tt|q nd}|||S)a A dict is abstracted as an unordered container of its values >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return {0: a, 1: b}') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Dict) {0: a, 1: b} => ['|a|', '|b|'] where the |id| notation means something that may contain ``id``. N) keysrFzipr-rZupdaterErrW)r$rV elts_aliasesrval elt_aliasesr"r"r# visit_Dicts    zAliases.visit_Dictcs,|jrfdd|jD}nd}||S)a A set is abstracted as an unordered container of its elements >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return {a, b}') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Set) {a, b} => ['|a|', '|b|'] where the |id| notation means something that may contain ``id``. cs$h|]}|D]}t|q qSr")rZr)r\eltaliasr:r"r# s z$Aliases.visit_Set..N)eltsrW)r$rVrkr"r:r# visit_Sets   zAliases.visit_SetcCsD|jsdS||j}tj|jvr||jtj}||jtj<dS)a# A side effect of computing aliases on a Return is that it updates the ``return_alias`` field of current function >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return a') >>> result = pm.gather(Aliases, module) >>> module.body[0].return_alias # doctest: +ELLIPSIS This field is a function that takes as many nodes as the function argument count as input and returns an expression based on these arguments if the function happens to create aliasing between its input and output. In our case: >>> f = module.body[0].return_alias >>> Aliases.dump(f([ast.Name('A', ast.Load(), None, None), ... ast.Constant(1, None)])) ['A'] This also works if the relationship between input and output is more complex: >>> module = ast.parse('def foo(a, b): return a or b[0]') >>> result = pm.gather(Aliases, module) >>> f = module.body[0].return_alias >>> List = ast.List([ast.Name('L0', ast.Load(), None, None)], ... ast.Load()) >>> Aliases.dump(f([ast.Name('B', ast.Load(), None, None), List])) ['B', '[L0][0]'] Which actually means that when called with two arguments ``B`` and the single-element list ``[L[0]]``, ``foo`` may returns either the first argument, or the first element of the second argument. N)rSrZr5RetIdr8r_)r$rVZ ret_aliasesr"r"r# visit_Returns %  zAliases.visit_Returnc sfdd}ddfdd}|j}t}|jrnHt|tjr?t|jt |jdgd\}}|r>|||}|||}n$t|tj rcj |} | D]} t | d ra|| |}| || |qL qLfd d |D|pqS) NcsHfdd|D}t}t|D] }|||qfdd|DS)Ncsg|] }j|p |hqSr")r7r\argr:r"r#r] szNAliases.call_return_alias..interprocedural_aliases..csh|]}|qSr"r")r\ra)expand_subscriptr"r#rqzMAliases.call_return_alias..interprocedural_aliases..)rFrrj return_alias)funcrZ arg_aliasesreturn_aliasesZargs_combinationryr$r"r#interprocedural_aliases s z:Aliases.call_return_alias..interprocedural_aliasescSs$t|tjrt|jtr|jjS|Sr)r.rL SubscriptrSrr)rVr"r"r#rys  z3Aliases.call_return_alias..expand_subscriptcsd|j}t|tjr0t|jjt|}|r0dd|jj|dD}|D]}|q$||}|S)NcSsg|]}t|qSr"rr[r"r"r#r]rzz@Aliases.call_return_alias..full_args..)rr.rLrTlendefaultsrZ)r|callrZextratailrwr:r"r# full_argss  z,Aliases.call_return_alias..full_args)NNrr{cs g|] }|jvr|qSr")r7rW)r\ar:r"r#r]:s z-Aliases.call_return_alias..)r|rFkeywordsr.rLrPr rNrQrrMr7hasattrrjrJ) r$rVrrr|r8_Z signaturerZ func_aliasesZ func_aliasr"r~r#call_return_alias s8          zAliases.call_return_aliasc Cs|||j}t|tjr|jdkr|||hS||}t}|D]>}t|t tj t fr5||q$||j vrC| |j |q$zt|}| |j|dWq$tyb||Yq$w|||S)a Resulting node alias to the return_alias of called function, if the function is already known by Pythran (i.e. it's an Intrinsic) or if Pythran already computed it's ``return_alias`` behavior. >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> fun = """ ... def f(a): return a ... def foo(b): c = f(b)""" >>> module = ast.parse(fun) The ``f`` function create aliasing between the returned value and its first argument. >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Call) f(b) => ['b'] This also works with intrinsics, e.g ``dict.setdefault`` which may create alias between its third argument and the return value. >>> fun = 'def foo(a, d): builtins.dict.setdefault(d, 0, a)' >>> module = ast.parse(fun) >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Call) builtins.dict.setdefault(d, 0, a) => ['', 'a'] Note that complex cases can arise, when one of the formal parameter is already known to alias to various values: >>> fun = """ ... def f(a, b): return a and b ... def foo(A, B, C, D): return f(A or B, C or D)""" >>> module = ast.parse(fun) >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Call) f((A or B), (C or D)) => ['A', 'B', 'C', 'D'] partialr")rbr|r.rLrPrQrWrrFrrTrr7rjr5rRr8rNNotImplementedError)r$rVfr{Z all_aliasesrSZapr"r"r# visit_Call=s( (       zAliases.visit_CallcCs||t|hSr)rWr5rRr`r"r"r#visit_AttributeszAliases.visit_AttributecCst|jtjr||j|jjD]}||qd}nRt}||j||j}|D]<}t|trPt|jtj r>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a): return a[0]') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Subscript) a[0] => ['a[0]'] If we know something about the container, e.g. in case of a list, we can use this information to get more accurate informations: >>> module = ast.parse('def foo(a, b, c): return [a, b][c]') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Subscript) [a, b][c] => ['a', 'b'] Moreover, in case of a tuple indexed by a constant value, we can further refine the aliasing information: >>> fun = """ ... def f(a, b): return a, b ... def foo(a, b): return f(a, b)[0]""" >>> module = ast.parse(fun) >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Subscript) f(a, b)[0] => ['a'] Nothing is done for slices, even if the indices are known :-/ >>> module = ast.parse('def foo(a, b, c): return [a, b, c][1:]') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Subscript) [a, b, c][1:] => [''] Nctx)r.slicerLZTuplerZrSrrrFrZSlicer rrWrgetattrZParamZStorerr)r$rVror8 value_aliasesrpr"r"r#visit_Subscripts0&        zAliases.visit_SubscriptcCs|jD]}||qdS)zO omp directive may introduce new variables, just register them N)ZdepsrW)r$rVZdepr"r"r#visit_OMPDirectives  zAliases.visit_OMPDirectivecCs6|j|jvrd}t||j||||j|jS)Nzxidentifier {0} unknown, either because it is an unsupported intrinsic, the input code is faulty, or... pythran is buggy.)rOr8rrCrW)r$rVerrr"r"r# visit_Names zAliases.visit_NamecsT|jr"t}t|jD]\}||}|fdd|Dq nd}|||S)a A tuple is abstracted as an ordered container of its values >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return a, b') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Tuple) (a, b) => ['|[0]=a|', '|[1]=b|'] where the |[i]=id| notation means something that may contain ``id`` at index ``i``. c3s|]}t|VqdSrr)r\rpir"r# sz&Aliases.visit_Tuple..N)rrrF enumeraterZrjrW)r$rVrkrormr"rr# visit_Tuples   zAliases.visit_TuplecCs |jh|j|jj<||dSr)targetr8rOrbr`r"r"r#visit_comprehensionszAliases.visit_comprehensioncCs,|jD]}||q||j||S)aw A comprehension is not abstracted in any way >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return [a for i in b]') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.ListComp) [a for i in b] => [''] ) generatorsrrZrorWr$rV generatorr"r"r#visit_ListComps   zAliases.visit_ListCompcCs8|jD]}||q||j||j||S)a} A comprehension is not abstracted in any way >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a, b): return {i: i for i in b}') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.DictComp) {i: i for i in b} => [''] )rrrZrrSrWrr"r"r#visit_DictComps    zAliases.visit_DictCompcst_jddjDjddjjDtj jvrKfddfddjtj Dfdd }|_ d Sd S) z Initialise aliasing default value before visiting. Add aliasing values for : - Pythonic - globals declarations - current function arguments css|] \}}||hfVqdSrr")r\rHr4r"r"r#r#sz,Aliases.visit_FunctionDef..css|] }|j|hfVqdSr)rOrvr"r"r#r&scsttjttjfrfddSttr$jjfddSttjrKzj j fdd}|WSt yJfddYSwttj rbj j fddSfddS) NcshSrr"r)expr"r#/sz@Aliases.visit_FunctionDef..parametrize..csfdd|DS)Ncsh|]}t|qSr"r)r\Zpc)rr"r#rq3sSAliases.visit_FunctionDef..parametrize....r"r)r pcontaineer"r#r3s cs,t|kr |hSjjt|hSr)rrrr)rVwr"r#r{;s  zDAliases.visit_FunctionDef..parametrize..return_aliascSrrJrr:r"r#rBcsfddDS)Nc s,h|]}D] }t||tqqSr")rLrZLoad)r\rSr)rslicesr"r#rqFsrr"r)rr-rr#rFs crrrrr:r"r#rKr)r.rLZConstantrrTrrrrMr ValueErrorrrSr)rr{)rV parametrizer$)rrrrr-rr#r,s&         z.Aliases.visit_FunctionDef..parametrizecsg|]}|qSr"r")r\Z ret_alias)rr"r#r]Rs z-Aliases.visit_FunctionDef..csfddDS)Ncsh|] }|D]}|qqSr"r")r\r{rxrr"r#rqWs  zJAliases.visit_FunctionDef..merge_return_aliases..r"r)r}rr#merge_return_aliasesVs z7Aliases.visit_FunctionDef..merge_return_aliasesN) r2copyr8rjZglobal_declarationsrrrbr5rtr{)r$rVrr")rVrr}r$r#visit_FunctionDefs     &   zAliases.visit_FunctionDefcCst||||j}|jD]?}t|tjrIt|p|h|j|j <t |D]}t|tjr=|j }|j| |f|j|<q&| ||j|j q||qdS)a Assignment creates aliasing between lhs and rhs >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse('def foo(a): c = a ; d = e = c ; {c, d, e}') >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Set) {c, d, e} => ['|a|'] Everyone points to the formal parameter 'a' \o/ N) mdrZrStargetsr.rLrMrFr8rOlistr_rW)r$rVrtrpZa_idr"r"r# visit_Assign]s      zAliases.visit_AssigncCsr||j}tdd|Drdd|D}n|jh}||j||j|j|j|jj<||||dS)a For loop creates aliasing between the target and the content of the iterator >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> module = ast.parse(""" ... def foo(a): ... for i in a: ... {i}""") >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Set) {i} => ['|i|'] Not very useful, unless we know something about the iterated container >>> module = ast.parse(""" ... def foo(a, b): ... for i in [a, b]: ... {i}""") >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Set) {i} => ['|a|', '|b|'] css|]}t|tVqdSr)r.r)r\xr"r"r#rsz$Aliases.visit_For..cSsh|]}|jqSr")r)r\Z iter_aliasr"r"r#rqsz$Aliases.visit_For..N) rZiterallrrWr7r8rOrb)r$rVZ iter_aliasesZtarget_aliasesr"r"r# visit_Forws  zAliases.visit_ForcCs||||dS)aD While statement evaluation is somehow equivalent to the evaluation of a sequence, except the fact that in some subtle cases, the first rounds of analyse fails because we do not follow the regular execution order >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> fun = """ ... def foo(a): ... while(a): ... if a == 1: builtins.print(b) ... else: b = a""" >>> module = ast.parse(fun) >>> result = pm.gather(Aliases, module) N)rbr`r"r"r# visit_Whiles zAliases.visit_WhilecCsZt||||jd}}z|j}|jD]}||q|j}||_Wn ty1Ynwz|jD]}||q6|j}Wn tyKYnw|ra|sa||_|jD]}||qV|j}|rv|sv||_|jD]}||qk|j}|r|r|D]#\}}||jvr|j| ||j|<q~t |t t fsJ||j|<q~dS|r||_dSdS)a After an if statement, the values from both branches are merged, potentially creating more aliasing: >>> from pythran import passmanager >>> pm = passmanager.PassManager('demo') >>> fun = """ ... def foo(a, b): ... if a: c=a ... else: c=b ... return {c}""" >>> module = ast.parse(fun) >>> result = pm.gather(Aliases, module) >>> Aliases.dump(result, filter=ast.Set) {c} => ['|a|', '|b|'] N) rrZrdr8rrerrfrr_r.r1rF)r$rVZ true_aliasesZ false_aliasestmpZstmtrHr4r"r"r#visit_IfsN                  zAliases.visit_IfcCs&|jr |jh|j|jj<||dSr)rUr8rOrbr`r"r"r#visit_ExceptHandlerszAliases.visit_ExceptHandlerr)(r&r'r(r)rtr% staticmethodrIrJrRrWrarcZ visit_BinOpZ visit_ComparergrnrsrurrZvisit_ConstantrrrrrZ visit_ListrrZ visit_SetCompZvisit_GeneratorExprrrrrrrr,r"r"r r#r5@sL      ,4A@ E'?r5c@seZdZdZddZdS) StrictAliaseszW Gather aliasing informations across nodes, without adding unsure aliases. cCstSr)rFr:r"r"r#rJrKz#StrictAliases.get_unbound_value_setN)r&r'r(r)rJr"r"r"r#rs r)(r)Z$pythran.analyses.global_declarationsrZpythran.intrinsicrrrZpythran.passmanagerrZpythran.syntaxrZpythran.tablesrr r Zpythran.unparser Zpythran.conversionr Zpythran.metadataZmetadatarZ pythran.utilsr ZgastrLrr itertoolsrr;r/r2objectrr0r-r3r5rr"r"r"r#s4          <