Upf1ddlTddlmZ ddlTddlmZmZddlZddl m Z m Z m Z m Z mZn#e$rZededZ[wwxYwd Zd Zejed Gd deZejed GddeZejZejed GddeZdS))*)_Dialect)get_default_loc_context_cextN)AnyListOptionalSequenceUnionz+Error loading imports from extension module arg_attrs res_attrsT)replacec(eZdZdZedZdS) ConstantOpz)Specialization for the constant op class.c&|jdjSNr)resultstypeselfs Y/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jaxlib/mlir/dialects/func.pyrzConstantOp.types|A##N)__name__ __module__ __qualname____doc__propertyrrrrrs333 $$X$$$rrc eZdZdZdddddfd ZedZedZedZedZ ed e fd Z ed Z dd e eefd ZedZejdeeeffdZedZedZejdefdZeddddede eede efdZxZS)FuncOpz%Specialization for the func op class.N) visibility body_builderlocipc<tt|}t|tr(t |d|d}t |}|'tt|nd}t||||||rI| } t| 5||ddddS#1swxYwYdSdS)a Create a FuncOp with the provided `name`, `type`, and `visibility`. - `name` is a string representing the function name. - `type` is either a FunctionType or a pair of list describing inputs and results. - `visibility` is a string matching `public`, `private`, or `nested`. None implies private visibility. - `body_builder` is an optional callback, when provided a new entry block is created and the callback is invoked with the new op as argument within an InsertionPoint context already set for the block. The callback is expected to insert a terminator in the block. rrinputsrN)sym_visibilityr%r&) StringAttrgetstr isinstancetuple FunctionTypeTypeAttrsuper__init__add_entry_blockInsertionPoint) rnamerr#r$r%r&sym_namer* entry_block __class__s rr3zFuncOp.__init__&sQ>>#d)),, dE " " E##47DG#DDD||D!!/9/EJNN3z?? + + +4  4CTVWWW  #..00K ,, # # T""" # # # # # # # # # # # # # # # # # # # #s6 DDDcHt|jdjdkSr)lenregionsblocksrs r is_externalzFuncOp.is_externalEs4<?)**a//rc|jdSr)r<rs rbodyz FuncOp.bodyIs|ArcZtt|jdjS)N function_type)r0r1 attributesvaluers rrz FuncOp.typeMs"HT__%EFFLMMMrc|jdS)Nr*)rCrs rr#zFuncOp.visibilityQs/00rreturnc6t|jdS)Nr7)r+rCrs rr6z FuncOp.nameUs$/*5666rc^|jrtd|jdjdS)Nz&External function does not have a bodyr)r> IndexErrorr<r=rs rr8zFuncOp.entry_blockYs1   GEFF F|A%a((rarg_locsc|jstd|jjj|jjd|i|jjdS)z Add an entry block to the function body using the function signature to infer block arguments. Returns the newly created block z(The function already has an entry block!rJr)r>rIr@r=appendrr))rrJs rr4zFuncOp.add_entry_block_sQ  IGHH H !1EHEEEy""rc@t|jtSN) ArrayAttrrCARGUMENT_ATTRIBUTE_NAMErs rrzFuncOp.arg_attrsjs)@ABBBr attributect|tr||jt<dSt||j|jt<dS)Ncontext)r.rOrCrPr,rTrrQs rrzFuncOp.arg_attrsnsU i + + 7@DO3 4 4 47@}}4<8E88DO3 4 4 4rc|jjSrN)r8 argumentsrs rrWzFuncOp.argumentsws))rc&|jtSrNrCRESULT_ATTRIBUTE_NAMErs r result_attrszFuncOp.result_attrs{s455rc$||jt<dSrNrYrUs rr[zFuncOp.result_attrss1:-...r)rr6r)rr6cfd}|S)aDecorator to define an MLIR FuncOp specified as a python function. Requires that an `mlir.ir.InsertionPoint` and `mlir.ir.Location` are active for the current thread (i.e. established in a `with` block). When applied as a decorator to a Python function, an entry block will be constructed for the FuncOp with types as specified in `*inputs`. The block arguments will be passed positionally to the Python function. In addition, if the Python function accepts keyword arguments generally or has a corresponding keyword argument, the following will be passed: * `func_op`: The `func` op being defined. By default, the function name will be the Python function `__name__`. This can be overriden by passing the `name` argument to the decorator. If `results` is not specified, then the decorator will implicitly insert a `ReturnOp` with the `Value`'s returned from the decorated function. It will also set the `FuncOp` type with the actual return value types. If `results` is specified, then the decorated function must return `None` and no implicit `ReturnOp` is added (nor are the result types updated). The implicit behavior is intended for simple, single-block cases, and users should specify result types explicitly for any complicated cases. The decorated function can further be called from Python and will insert a `CallOp` at the then-current insertion point, returning either None ( if no return values), a unary Value (for one result), or a list of Values). This mechanism cannot be used to emit recursive calls (by construction). cp ddlm tj|}d}|jD]A}|j|jkrd}|jdkr"|j|j ks|j|j krd}Bdu}p|j t |rgn}|}t|5|jj}i}|r||d<||i|} |st% | Jdn| g} nt'| t(rt%| } ngt'| t*r| g} nNt'| t,r | jj} n,t'| t2r| j} nt%| } | d | D t  }t6 ||jd <dddn #1swxYwY fd } | } |j | _ || _| S) Nr)funcFTfunc_opr()r6rzeCapturing a python function with explicit `results=` requires that the wrapped function returns None.cg|] }|j Sr )r).0vs r z:FuncOp.from_py_func..decorator..s#B#B#BqAF#B#B#BrrBct|}dStdkr|jS|jS)Nr)CallOpFlatSymbolRefAttrr,r;resultr) call_argscall_opr_ return_types symbol_names r emit_call_opz.decorator..emit_call_ops\++ "3"7"7 "D"Di '4&&!++">)"?*r)r_inspect signature parametersvalueskind VAR_KEYWORDr6POSITIONAL_OR_KEYWORD KEYWORD_ONLYrr0r,r5r4r8rWlistr.r/ValueOpView operationr OperationReturnOpr1rCr`)fsighas_arg_func_opparamimplicit_returnrBr` func_args func_kwargs return_valuesrmwrappedr_rkrlr"r)r6rs @@@r decoratorz&FuncOp.from_py_func..decorators      #A&&C#O..00 + +:!222&*O:**J%"===zU%777&*O&oO,!*K(,,_'Irr'-Mf+MBBBG 7 7 9 9::# V# V#/9  "5-4K * !9 < < < &V#'==L(00K1000 %,(* #M599 <(,](;(; #M599 <)6 #M6::<(5(?(G #M9==<(5(= (,](;(; MM-000#B#BM#B#B#BL$0$4$4%|%5%%M;C,,}:U:UG&7G# V# V# V# V# V# V# V# V# V# V# V# V# V# V# VJ + + + + + + +#G zG %GONsD,HHHr )r"rr6r)rs```` r from_py_funczFuncOp.from_py_funcs@JI I I I I I I I VrrN)rrrrr3rr>r@rr#r+r6r8r r Locationr4rsetterr rOrwrWr[ classmethodTyper-r __classcell__r9s@rr"r""sI//)-4Td#######>00X0XNNXN11X17j777X7))X) # #(1C(D # # # #CCXC5D#9**X*66X6;i;;;;-1" oooo(4.)osm ooo[ooooorr"c veZdZdZ dddddeeeefdeeee fde effdZ xZ S) rfz%Specialization for the call op class.Nr%r&calleeOrResultsargumentsOrCalleerWc 8t|trt|ts"tddt |z|tdt |jjt |j j t||||dSt|tr"tddt |zt|tr(t |||||dSt|trOt |t |t||||dSdS) a Creates an call operation. The constructor accepts three different forms: 1. A function op to be called followed by a list of arguments. 2. A list of result types, followed by the name of the function to be called as string, following by a list of arguments. 3. A list of result types, followed by the name of the function to be called as symbol reference attribute, followed by a list of arguments. For example f = func.FuncOp("foo", ...) func.CallOp(f, [args]) func.CallOp([result_types], "foo", [args]) In all cases, the location and insertion point may be specified as keyword arguments if not provided by the surrounding context managers. zewhen constructing a call to a function, expected the second argument to be a list of call arguments, zgot Nz?unexpected third argument when constructing a callto a functionrSrzawhen constructing a call to a function by name, expected the second argument to be a string or a zFlatSymbolRefAttr, got )r.r"rw ValueErrorrr2r3rrgr,r6rD_get_default_loc_contextr-)rrrrWr%r&r9s rr3zCallOp.__init__s> ov . . /66  M6T"344667 $ & GG  $,!%%#(.8PQT8U8U&"     F ' . . FED1B,C,CEEF  '): ; ;  GG  !2I32      )3 / /  GG  !%%%/G/L/L&        rrN) rrrrr r"r rrgr-r r3rrs@rrfrfs// %) K  KKKvtDz12K!'8#!=>KD> KKKKKKKKKKrrf) _func_ops_genrir _ods_commonrrr _ods_cextrotypingr r r r r ImportErrore RuntimeErrorrPrZregister_operationrr"rr_rfr rrrs ###### M NNN;;;;;;;;;;;;;;;MMM ,D E E1LM&#h555$$$$$$$65$h555PPPPPVPP65Pfh555NNNNNVNN65NNNs+A <A