o Ǝi @s$ dZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z m Z ddlmZmZmZmZmZmZddlmZddlmZdd lmZmZmZmZdd lmZerddd l m!Z!eej"Gd d d Z#eej"GdddZ$ej%dkrdej$de$fddZ&nej%dkrdej$de$fddZ&n dej$de$fddZ&GdddZ'ej%dkrde(de)fddZ*nej%dkrde(de)fddZ*nde(fddZ*de'dd de(d!ee+d"eed#ee$de$f d$d%Z,d#e$de$fd&d'Z-d#e$de)fd(d)Z.dd+ed,e)de$fd-d.Z/de$fd/d0Z0d1e+de1e$fd2d3Z2d4ee$e1e$fde1e$fd5d6Z3d4ee$e1e$fde1e$fd7d8Z4d9e+d:e)de1e$fd;d<Z5d9e+de1e$fd=d>Z6de(de$fd?d@Z7d#e$de$fdAdBZ8d1e+de1e$fdCdDZ9 EddFee+dGee+dHe)de1e$fdIdJZ:de+de1e$fdKdLZ;dMe+de1e$fdNdOZe1e+ee+e+gdfffdUdVZ?dWe+de>e1e+ee+e+gdfee+gdfffdXdYZ@d1e+de1e+fdZd[ZAdWe+de>e1e+eed\e+gdfffd]d^ZBeej"Gd_d`d`ZCd1e+de1e+fdadbZDdce e+de+fdddeZEdfe1eCddfdgdhZFdieGde1eCfdjdkZHdfe1eCdeGfdldmZIdne1e$doe+de>eGeGffdpdqZJdreKe+e$fdse+dee$fdtduZLdne e$ddfdvdwZMeNejOZPdxe$ddfdydzZQdne1e$d{e+de$fd|d}ZRdne1e$ddfd~dZSdeGdne1e$ddfddZTdne1e$de1eCfddZUdfe1e#deKe$e+fddfddZVdne1e$ddfddZWdne1e$ddfddZXdne1e$ddfddZYde$de1e$de1e$fddZZdne1e$de1e$fddZ[dne1e$ddfddZ\dne1e$ddfddZ]ddddZ^dne1e$ddfddZ_dne1e$ddfddZ`dne1e$ddfddZadejbdne1e$ddfddZcdne1e$de+fddZdde$de+fddZedne e$ddfddZfdne e$ddfddZgdeGde(fddZhdejbddfddZieNejjZkeNejlZmeNejnZoeNejpZqdeKe(efd+ede+fddZr ddne1e$deKe(efdeedefddfddZsdne1e$ddfddZtejude1e(fddZv Eddejbdee1e$eKe(efgedfde)de>ejbedffdd„Zwdne1e$de1e(deKe(efde>e1e$ejbffddńZxdne e$deddfddȄZyddejbde)de1e$fddʄZzdne e$de1e$fdd̄Z{eju Eddejbde)de e$fdd΄Z|e}Z~dde(de)de(fddфZdejbde)fddӄZ  * *ddedefdee eefde)de)de1e$f ddلZdS)a This module provides utilities for analyzing, transforming and manipulating Python bytecode. It includes functionality for: - Converting between different bytecode formats and versions - Virtualizing jumps and managing jump targets - Handling exception tables and their entries - Managing instruction offsets and extended arguments - Providing a clean API for bytecode modification and transformation - Supporting Python version-specific bytecode features - Generating bytecode from template functions The module is designed to work across different Python versions (3.7+) and handles version-specific bytecode differences transparently. N)IterableIteratorMappingSequence)AnyCallablecastOptional TYPE_CHECKINGUnion)dataclass_slots)config) get_indexofpropagate_line_numsremove_extra_line_numsstacksize_analysis)is_safe_constant)DynamoTracerOutputc@sVeZdZUded<ded<ded<eed<eed<defdd Zd edefd d Z d S)InstructionExnTabEntry Instructionstartendtargetdepthlastireturnc Cs:d|jd|jd|jd|jd|jd S)NzInstructionExnTabEntry(start=z, end=z , target=z, depth=z, lasti=))rshort_inst_reprrrrrselfr"a/home/jeff/fluffinator/venv/lib/python3.10/site-packages/torch/_dynamo/bytecode_transformation.py__repr__3szInstructionExnTabEntry.__repr__ocCsJt|tsdS|j|juo$|j|juo$|j|juo$|j|jko$|j|jkSNF) isinstancerrrrrr)r!r%r"r"r#__eq__;s      zInstructionExnTabEntry.__eq__N) __name__ __module__ __qualname____annotations__intboolstrr$objectr(r"r"r"r#r*s rc@seZdZUdZeed<eed<eeed<eed<dZ eeed<dZ eeed<d Z e ed <dZ ed ed <dZeded <dZeeed<dZeeed<defddZdede fddZdefddZdddZdS)rz$A mutable version of dis.InstructionopcodeopnameargargvalNoffset starts_lineFis_jump_target dis.Positions positionsr exn_tab_entryargreprrcCst|SNidr r"r"r#__hash__YzInstruction.__hash__othercCst|t|kSr<r=r!rAr"r"r#r(\szInstruction.__eq__cCsd|jd|jdS)NzInstruction(opname=z , offset=r)r2r5r r"r"r#r_szInstruction.short_inst_reprcCs|j|_|j|_dSr<)r6r9rBr"r"r#copy_positionsbs zInstruction.copy_positions)rArrN)r)r*r+__doc__r-r,r/r rr5r6r7r.r9rr:rr;r?r0r(rrCr"r"r"r#rGs"   r irc C&t|j|j|j|j|j|j|j|jSr<) rr1r2r3r4r5 line_numberr7r9rHr"r"r#convert_instructionirLrF c CrIr<) rr1r2r3r4r5r6r7r9rKr"r"r#rLwrMc Cs$t|j|j|j|j|j|j|jdSr<)rr1r2r3r4r5r6r7rKr"r"r#rLsc@seZdZdefddZdS) _NotProvidedrcCdS)NrPr"r r"r"r#r$z_NotProvided.__repr__N)r)r*r+r/r$r"r"r"r#rPsrPrF namecCs|dvS)N) LOAD_ATTR LOAD_GLOBALLOAD_SUPER_ATTRr"rUr"r"r#inst_has_op_bitsr@rZcCs|dkS)NrWr"rYr"r"r#rZr@cCrQr&r"rYr"r"r#rZrR)r3r4rr3r4rcCst|r|dur td|durd}n|du|tu|du}|dkr'td|dur4t|ts4tdttj|||||dS)a At most one of `arg`, `argval`, and `target` can be not None/_NotProvided. This is to prevent ambiguity, e.g. does create_instruction("LOAD_CONST", 5) mean load the constant at co_consts[5], or load the constant 5? If `arg` is not provided, it will be computed during assembly from `argval` or `target`. Bits in the args of instructions LOAD_GLOBAL, LOAD_ATTR (3.12+), and LOAD_SUPER_ATTR modify the behavior of the instruction. In this case, we allow both `arg` and `argval` to be set. The value of `arg` here is expected to be the value of the op bits and the true value of `arg` will be computed during assembly. If `arg` is not set, the bits are assumed to be 0. Nz*target cannot be specified for instructionrrz@only one of arg, argval, and target can be not None/_NotProvidedz#instruction arg must be int or None)r1r2r3r4r)rZ RuntimeErrorrPr'r-rdisopmap)rUr3r4rcntr"r"r#create_instructions r_cCtjdkrdnd}t||dS)NrN JUMP_FORWARD JUMP_ABSOLUTErsys version_infor_)rinstr"r"r#create_jump_absolute rhcCs |jdvS)N)rarb)r2rcr"r"r#is_jump_absolutes rjTvalcheckedcCs&|r t|s Jd|td|dS)z In general we should only create `LOAD_CONST` for immutable objects, but sometimes it's convenient _and safe_ for Dynamo create `LOAD_CONST` for mutable objects. In such cases, use `checked=False`. zunsafe constant LOAD_CONSTr4)rr_)rkrlr"r"r#create_load_consts rocCstjdkr tdddStdS)NrNCOPYrr3DUP_TOPrdr"r"r"r#create_dup_tops  rsncCs|dkrgStjdkrddt|ddDStjdkr:|dkr: td|d td |d td|dd td |dd gS|d krKtd gd |dgStd|d gS)a Returns a "simple" sequence of instructions that rotates TOS to the n-th position in the stack. For Python < 3.11, returns a single ROT_* instruction. If no such instruction exists, an error is raised and the caller is expected to generate an equivalent sequence of instructions. For Python >= 3.11, any rotation can be expressed as a simple sequence of swaps. rrNcSsg|]}td|dqS)SWAPrq)r_.0rHr"r"r# z create_rot_n..rF  BUILD_TUPLErqUNPACK_SEQUENCEROT_)TWOTHREEFOURr ROT_N)rerfranger_rtr"r"r# create_rot_ns    r inst_or_instscs,t|tr |gn t|tsJ|dtdtffdd }dtddffdd }tjdkrGtd jr>|d s>|d St d gStjd krwtd jr]|d s]|d Sd jd krn|d sn|d St d gStjdkrtd jr|d s|d St d gS)a Appends or prepends a PUSH_NULL instruction to `inst_or_insts`, depending on Python version. Used when you know that `inst_or_insts` generates a callable that will be called. NOTE: Assumes `inst_or_insts` is a single instruction or sequence of instructions that pushes exactly 1 object to the stack that is to be called. It is important that you include ALL instructions that construct the callable - not just the first instruction/a prefix. Will attempt to use the NULL push bit for instructions with such bits (LOAD_GLOBAL 3.11+, LOAD_ATTR 3.12+, LOAD_SUPER_ATTR). In this case, instructions WILL be modified. idxrcs$|jdus J|jd@dkSNrrqrinstsr"r#inst_has_bit_set*sz'add_push_null..inst_has_bit_setNcs(|jdus J|jdO_dSrrqrrr"r# set_inst_bit.sz#add_push_null..set_inst_bitrErz PUSH_NULLrSrrWrN) r'rlistr-r.rerfrZr2r_)rrrr"rr# add_push_nulls6      rcCst|tr |g}n t|tsJ|}tjdkr|Stjdkr dnd}||jdkrF||jdus2J||jd@dkrF||jdO_|StjdkrT|tdg}|Stdg|}|S) zLike add_push_null, but the low bit of LOAD_ATTR/LOAD_SUPER_ATTR is not set, due to an expected CALL_FUNCTION_EX instruction. rNrErzrrWNrr)r'rrrerfr2r3r_)rrrr"r"r#add_push_null_call_function_exNs"   rnargs push_nullcCstjdkr=g}|r$|tdtjdkr|dn|d}|t|tjdkr2|td|d|td |d|Std |dgS) aS Creates a sequence of instructions that makes a function call. `push_null` is used in Python 3.11+ only. It is used in codegen when a function call is intended to be made with the NULL + fn convention, and we know that the NULL has not been pushed yet. We will push a NULL and rotate it to the correct position immediately before making the function call. `push_null` should be True if no NULL is pushed for the callable. Conversely, `push_null` should be False if a NULL was pushed for the callable. Prefer using `push_null=False` when possible since we will not need to rotate NULL to the right place, which is less efficient. Generally, you should codegen a function by using `add_push_null` then `create_call_function` with `push_null=False`. Example of when to set push_null False: insts = [ create_instruction("LOAD_GLOBAL", argval="torch"), create_instruction("LOAD_ATTR", argval="nn"), create_instruction("LOAD_ATTR", argval="functional"), create_instruction("LOAD_ATTR", argval="relu"), ] insts = add_push_null(insts) insts.append(create_instruction("LOAD_FAST", argval="x")) insts.extend(create_call_function(1, False)) Example of when to set push_null True: insts = [create_instruction("LOAD_FAST", x)] for should_wrap, wrapper_name in wrappers: if should_wrap: insts.extend([ create_instruction("LOAD_GLOBAL", argval="wrapper1"), create_instruction("SWAP", arg=2), *create_call_function(1, True), ) rNrrErr rSPRECALLrqCALL CALL_FUNCTION)rerfappendr_extendr)rroutputrotsr"r"r#create_call_functionls ) rcCsHtjdkr td|dgStjdkrtd|dtd|dgStd|dgS)NrSrrqrNr CALL_METHODrd)rr"r"r#create_call_methods    rcCs$tjdkr tdd|dStd|dS)NrSrVr)r3r4 LOAD_METHODrnrdrYr"r"r#create_load_methods  rcCr`)NrN BEFORE_WITH SETUP_WITHrcrd)rr2r"r"r#create_setup_withrirc Cstjdkr td|dgS|dkrgS|dkrtdgS|dkr'tdtdgS td |ddtd td d d tdtdtd tdtd d d tdtd tdg tdtdtd|ddS)NrNrurqrr ROT_TWOrF ROT_THREE BUILD_LISTrrrmrzrn BINARY_SUBSCR STORE_SUBSCRreverserPOP_TOPr)rerfr_rrrr"r"r# create_swaps6      rFrrstorecCsXtjdkr|r dnd}t|t|t|gS|rdnd}t|t|tdddt|gS) zQ BINARY_SLICE and STORE_SLICE (if `set` is True) for all Python versions rS STORE_SLICE BINARY_SLICErr BUILD_SLICEr rq)rerfror_)rrr inst_namer"r"r#create_binary_slices    rcCs>tjdkr td|dgSgt|tt|dtdS)NrNrprqrr )rerfr_rrsrKr"r"r# create_copys  rrcCs@gttdtdt|tjdkrdndtddtdS)NrmrnrNr rFr)rr_printrrerfr)rr"r"r#create_print_on_stacksrvaluecCs2gttdtdtd|dtddtdS)NrmrnrFr)rr_rr)rr"r"r#create_print_values rlinenobytenocs8tjdksJgdtdtddffdd }|fS)z Used to create typing.CodeType.co_lnotab See https://github.com/python/cpython/blob/main/Objects/lnotab_notes.txt This is the internal format of the line number table if Python < 3.10 r{ lineno_new byteno_newrNcs|ks|krAtdt|d}tdt|d}|dks&|dks&J|7|7||d@f|ks|ksdSdS)Nrimaxminr)rr byte_offset line_offsetrrlnotabr"r#update/szlnotab_writer..updatererfr-)rrrr"rr# lnotab_writer$s r first_linenocstjdkr tjdks Jg|dddtdtddffdd d td tddffd d }dtddffdd }||fS)z Used to create typing.CodeType.co_linetable See https://github.com/python/cpython/blob/main/Objects/lnotab_notes.txt This is the internal format of the line number table for Python 3.10 r{rNr byteno_delta lineno_deltarNcs~|dks|dkr=tdt|d}tdt|d}|dks"|dks"J||8}||8}||d@f|dks|dksdSdS)Nrirrr)rrrr) linetabler"r#_updateJsz%linetable_310_writer.._updaterrcs&|}||||dSr<r")rrr)rrrrr"r#rSs  z$linetable_310_writer..update total_bytescs|dSr<r")r)rrrr"r#r[sz!linetable_310_writer..endr)rrrr")rrrrrr#linetable_310_writer<s  rcCsX|dksJ|d@g}|dL}|dkr*|ddO<||d@|dL}|dks|S)z~ 6-bit chunk encoding of an unsigned integer See https://github.com/python/cpython/blob/3.11/Objects/locations.md r?rz@)r)rtbr"r"r# encode_varintas  rr8cs>tjdksJg|dtddtddffdd }|fS) z Used to create typing.CodeType.co_linetable See https://github.com/python/cpython/blob/3.11/Objects/locations.md This is the internal format of the line number table for Python 3.11 rNr9r8 inst_sizerNcstrjnd}dtdtddffdd }|durd}n|}||dkr3||d|d8}|dks&|||dS)Ndeltasizercsd|kr dksJJd}r?jdur?jdur?jdur?jdur?d|djjjdjdf}n d|d|dkrT| d>dB}n|dK}t||D] }t|qadS)Nrr"r)r end_lineno col_offsetend_col_offsetrrr)rr other_varintsrt)rr9r"r#rs*     z5linetable_311_writer..update.._updaterr)rr-)r9rrrrrr)r9r#r|s  z$linetable_311_writer..update)rerfr r-)rrr"rr#linetable_311_writerps  .rc@s6eZdZUeed<eed<eed<eed<eed<dS)ExceptionTableEntryrrrrrN)r)r*r+r-r,r.r"r"r"r#rs  rcCsv|dksJ|d@g}|dL}|dkr"||d@|dL}|dks|tt|dD] }||dO<q.|S)zR Similar to `encode_varint`, but the 6-bit chunks are ordered in reverse. rrrrr)rrrlen)rtrrHr"r"r#encode_exception_table_varints  r bytes_itercCs@t|}|d@}|d@r|dK}t|}||d@O}|d@s |S)z5 Inverse of `encode_exception_table_varint`. rrr)next)rrrkr"r"r#decode_exception_table_varints rtabcCsftt|dD](}||j||jkr.||j||djkr.||dj||djks0JqdS)z Verifies that a list of ExceptionTableEntries will make a well-formed jump table: entries are non-empty, sorted, and do not overlap. rN)rrrr)rrHr"r"r#check_exception_tables "rexntabc Cst|}g}z3 t|d}t|d}||d}t|d}t|}|d?}t|d@} |t||||| qtyHt||YSw)z Parse the exception table according to https://github.com/python/cpython/blob/3.11/Objects/exception_handling_notes.txt Tr r)iterrr.rr StopIterationr) r exntab_iterrrlengthrrdlrrr"r"r#parse_exception_tables"      rcCsg}|D]@}t|jd}|ddO<|||j|jd}|t|d|t|jd|jd>|j}|t|qt|S)zd Inverse of parse_exception_table - encodes list of exception table entries into bytes. r rr)rrrrrrrbytes)rrentry first_entryrrr"r"r#assemble_exception_tables r instructions firstlinenoc Csng}tjdkrpt|\}}d}t|D][\}}|jdkr;d}|d7}dD]} ||| jdkr9||| j|_nq$n t|d|}d}||j|d}|jpQd} ||j | d@ft t|ddD]} |dqfqn?tjd kr|t |\}}nt |\}}} |D]}|j d ur||j t||jpd} ||j | d@fqtjd kr| t|t|t|fS) z)Do the opposite of dis.get_instructions()rNr EXTENDED_ARGrrr rFr r)rrr{N)rerfr enumerater2r9instruction_sizer3rr1rrrr6rr) rrcoder update_linenonum_extrHrgrjr3_rr"r"r#assemble sF           roffset_to_instr5cCs2dD]}|||jtjkr|||SqdS)zU Get the instruction located at a given offset, accounting for EXTENDED_ARGs )rr rrNr1r\r)rr5rtr"r"r#_get_instruction_by_offset3s rcCsBdd|D}|D]}|jtjvs|jtjvrt||j|_q dS)z9Replace jump targets with pointers to make editing easiercSsi|] }|jdur|j|qSr<)r5rwrgr"r"r# Asz$virtualize_jumps..N)r1r\hasjabshasjrelrr4r)r jump_targetsrgr"r"r#virtualize_jumps?sr  instructioncCsrtjdkr tdd|jvr|jdd|_nd|jvr%|jdd|_ntdtj|j|_|jt vs7JdS)NrNz+Cannot flip jump direction in Python < 3.11FORWARDBACKWARDz-Instruction is not a forward or backward jump) rerfr[r2replaceAttributeErrorr\r]r1 _REL_JUMPS)r r"r"r#flip_jump_directionMs   rrcCsD||}dD]}||kr|||jtjkr|||}q|S|S)zp i.e. get the first EXTENDED_ARG instruction (if any) when targeting instructions[idx] with a jump. rr)rrrr5r"r"r#_get_instruction_frontZs rcCsttjttj}|D]G}|j|vrT|jtjvrT|jdur*|jjdur*|jdus,J|jj|jkrFtj dkr|j|j krUt ||_ q/WdSt ybYdSw)zDReplace exception table entries with pointers to make editing easiercSsi|] }tt|j|qSr")rr-r5rr"r"r#rsz.virtualize_exception_table..rrcst}tkr"|jkr"d7tkr"|jksdks(Jd}tt|jt|t|j|j|j}||fS)Nrr) rrrrrrrrr)r end_offset inst_entryend_offset_idx exn_tab_iterroffsetsr"r#steps    z(virtualize_exception_table..stepN) rsortedkeysrtuplerrr5rrcopyr:r)rrexn_tabr!rrrgr"rr#virtualize_exception_tables(        r'c sit|}|D]X}|jr`t|||jjj}|dusJtt|jjjt|jjd}|dus3Jt|||jj j}|dusCJ||f}||jj |jj f}|vr\||ks\J||<qt ddd}dggd fdd } |D]j}rd d |dkr| rd d |dksrd d|dkr|d krd d ksJJtd d} | |dkrވt| |ddgd R|d|q}r| stS) zMCompute exception table in list format from instructions with exn_tab_entriesNr cS|d|d fSNrrr"tr"r"r#z)compute_exception_table..keyrrcsZr)}|dkr+tt|d|dg|R|dddSdSdS)zT Pop the key_stack and append an exception table entry if possible. rrr N)poprrrr.exn_dictr& key_stacknextir"r#r0s "z$compute_exception_table..poprzr)rN)rr:rrr5rr-rrrrrr"r#rrrr) rrrgrrrr/rk keys_sortedr0leftr"r1r#compute_exception_tablesh       >   r7rcCsg}|D]N}||j||jf}|r,|dd|dkr,||r,|dd|dks|rM|dd|dkrJ|dkrJ|ddksMJJ||qdS)z Checks `tab` is a properly sorted list of nested InstructionExnTabEntry's, i.e. no entries partially overlap. "Properly sorted" means entries are sorted by increasing starts, then decreasing ends. rzrrN)rrr0r)rr entry_stackrr/r"r"r#!check_inst_exn_tab_entries_nesteds > r9cst|}i|D]#}|jr+||jj||jjf}|vr&|j|ks&J|j|<qfddtdddD}t|||D]}t||j||jdD] }t|||_qSqDdS)z~ Copies exception table entries to all instructions in an entry's range. Supports nested exception table entries. cg|]}|qSr"r")rwr/entriesr"r#rx;sz4propagate_inst_exn_table_entries..cSr(r)r"r*r"r"r#r,<r-z2propagate_inst_exn_table_entries..r.rN) rr:rrr"r#r9rr%)rrrgr/sorted_entriesrrHr"r;r# propagate_inst_exn_table_entries+s(     r>cCst|}t}t|D]K\}}|jrVtjdksJt|j|vs"J|t|j|j}|j|vs4J|j |vs;J|j |vsBJ||j|krS||j ksVJJq dS)aJ Checks that exn_tab_entries of instructions are valid. An entry's start, end, and target must be in instructions. Instructions with an exn_tab_entry are located within the entry's start and end instructions. Instructions do not share exn_tab_entries. Implicitly checks for no duplicate instructions. rNN) rrrr:rerfr>addrrr)rrexn_tab_entry_setrHrgrr"r"r# check_inst_exn_tab_entries_validFs (rAcCsdd|D|dd<dS)NcSsg|] }|jtjkr|qSr"rrvr"r"r#rx_z'strip_extended_args..r")rr"r"r#strip_extended_args^srCold_inst new_instscCs|jr|jj|urt|dkr|d|j_|ddD] }t|j|_|j|_q|dj|_|dj|_|dj|_|dj|_|dj |_ |g|ddS)Nrrzr) r:rrr%r9r1r2r3r4r)rDrErgr"r"r#overwrite_instructiongs         rFcCsJtjdksJddd}|D]}|j|vr"||j|_tj|j|_q|S)zFLOAD_METHOD puts a NULL on the stack which causes issues, so remove itrNrVr)rr)rerfr2r\r]r1)rrewritesrgr"r"r#remove_load_call_method~s   rHcCsg}|D]H}d|jvrGtdtd|jvd}|j|_tjdkr.td|jvr'dnd|jd }ntd |jd }td dd ||g}|t ||q| |q||dd<dS) N_NONEIS_OPNOTrqrSr POP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUErcPOP_JUMP_IF_TRUErmrn) r2r_r-r3r4rerfrrrFr)rrErgis_opjump_op replace_instsr"r"r#remove_jump_if_nones(     rRcCsg}|D]A}|||jdvrEt|jdd}|jr&|jj|ur&||j_t|j|_|j|_tj d|_ d|_d|_ d|_ ||q||dd<dS)N)rrSLICESUBSCRrr ) rr2r_rr:rr%r9r\r]r1r3r4)rrErg subscr_instr"r"r#remove_binary_store_slices     rV) LOAD_FASTrW) STORE_FASTrX)rXrW)LOAD_FAST_LOAD_FASTSTORE_FAST_STORE_FASTSTORE_FAST_LOAD_FASTcCstg}|D]-}|jtvr,t|j\}}|j\}}t||dt||dg}|t||q||q||dd<dS)Nrn)r2 FUSED_INSTSr4r_rrFr)rrErginst0inst1argval0argval1rQr"r"r#remove_fused_load_stores     racCs`g}|D]#}d|jvr"tdddt|j|jdg}|t||q||q||dd<dS)NRETURNNOPGRAPH_BREAK_IF_LEAFrn)r2r_r4rrFr)rrErgrQr"r"r#$add_graph_break_if_leaf_instructionss   recCsg}t||ddD]^\}}|jdkrd|jdkrd|jdrdtt|D]=}||j|ur3|||_||jrb||jj|urF|||j_||jj |urT|||j_ ||jj|urb|||j_q%q | |q | |d||dd<dS)Nrrcrdrbrz) zipr2r4 startswithrrrr:rrr)rrErg next_instrHr"r"r#'remove_graph_break_if_leaf_instructionss*         rirc CsF|jpd|jpd}t|jsdSg}t|D]\}}|||jdkr|jdkr||d}|jdkrt j dkr?|jdksXt j d krNt j dkrN|jd ksXt j d kr|jd krd |vs^J|t d d d|jd}||vrz|t d |dn |t d|dd|_d|_|jd kr||d}d|_d|_q||dd<dS)z3convert super() with no args into explicit arg formr"NrWsuperrrrSrrNrr __class__ LOAD_DEREFrnrWr ) co_cellvars co_freevarsr co_varnamesrrr2r4r3rerfr_) rr cell_and_freerrrgr4 first_var call_instr"r"r#explicit_supers8           rscsJgdtddffdd }|D]}|jtjkrd|_nn|jrL|jdkrL|dtd |jd ?d td |jd ?d td |jd ?d n=|jrq|jdkrq|dtd |jd ?d td |jd ?d n|jr|jdkr|dtd |jd ?d |qtt|}|dksJ|dd<|S)z,Fill in correct argvals for EXTENDED_ARG opsrtrNcs.t|D]}rdjtjkrqdS)Nrz)rr1r\rr0)rtrrr"r# maybe_pop_n)s z&fix_extended_args..maybe_pop_nrirFrrqrir rr)r-r1r\rr3rr_r)rrurgaddedr"rtr#fix_extended_args%s,    ryrgcCs0ddl}tjdkrd|jjjj|jdSdS)NrrNr r)torchrerf_C_dynamo eval_framepy_opcode_cachesr1)rgrzr"r"r#rFs rcCs,d}|D]}|j|ks J|t|7}qdSNrr5rrr5rgr"r"r# check_offsetsNs rcCs$d}|D] }||_|t|7}qdSrrrr"r"r#rUs rargscGsVtttt|}dd|gt|ddt|d|dDgD}dd|S)NcSs g|] }ddd|DqS) css|]}|dVqdS)03Nr")rwxr"r"r# _sz)debug_bytes...)join)rwr3r"r"r#rx^szdebug_bytes..cSsg|] \}}t||kqSr")r-)rwarr"r"r#rxbrBrzzbytes mismatch  )rrmaprrrfr)rindexresultr"r"r# debug_bytes\srcCsVt|dddd\}}|j|jksJt|j|j|j|jks)Jt|j|jdS)z.T)safeN)transform_code_objectco_coder co_lnotab)rdoderr"r"r# debug_checkshs"r code_optionscCsHt|dD] \}}||ur|Sq|d|f7<t|ddS)N co_constsr)rr)rrkrHvr"r"r#get_const_indexus rvarname_from_oparg.c sddtdDdtdtffdd }tjdkr=|dus"Jd dtd Dd dtd d Dn=t|sCJitD]}z ||}||<WqIty_Ynwfddd Dfddd d Dt t D]dt ffdd }j dkr͈j tusJtjdkrˆjdusJ|j d>ttjd_q|j _qj dkrj tusJtjdkrjdusJ|j d>ttjd_q|j _qj dkrDjdus!Jj tus+J|j d>ttjdd_qj tvrtjdksTJtj ts_Jt j dkskJtfddj D}|dd>|dd@_qjtvr|rtjdkrj vrj _qj _qjtvr|r|j _qjtvr|rj _qjtvr jdur tj }|dksJ|_qdS)NcSi|]\}}||qSr"r"rwrrUr"r"r#rzfix_vars..co_namesrUrcsbz|}W|Sty0t}|<gd|Rd<tdtks-JY|Sw)Nr)KeyErrorr)rUr)rnamesr"r#get_name_indexs  z fix_vars..get_name_indexrNcSrr"r"rr"r"r#rrrocSrr"r"rr"r"r#rsrmrnci|]}||qSr"r"rwrUallnamesr"r#rrcrr"r"rrr"r#rscsjtuSr<)r4rPr")rHrr"r#should_compute_argsz$fix_vars..should_compute_argrWrr rVrSrXrEc3s(|]}|vr |n|VqdSr<r"r) freenamesvarnamesr"r#rs  zfix_vars..rr)rr/r-rerfcallable itertoolscount IndexErrorrrr.r2r4rPr3rr\r'r$r1 HAS_LOCALHAS_NAMEHAS_FREE HAS_CONSTr)rrrrrrUr arg_tupler")rrrrHrrrr#fix_varss              rcCsP|D]#}|jtur%|jtvs|jtvs|jtvs|jtvr%|jdvr%d|_qdS)N)rWrVrX) r4rPr1rrrrr2r3)rrgr"r"r#clear_instruction_argss      rcCsdg}|d|gdtjdkr|d|dtjdkr)|dn|d tjdkr8|d |d d g|S) N co_argcountco_posonlyargcount) co_kwonlyargcount co_nlocals co_stacksizeco_flagsrrrro co_filenameco_namerN co_qualnameco_firstlinenor{ co_linetablerco_exceptiontablernrm)rrrerf)r#r"r"r# get_code_keyss&         rtransformationsrrc sdt}fdd|D}t|d|dksJt|}t||||}t|||\}}||fS)Ncsi|]}|t|qSr")getattrrwkrr"r#r1ryz)transform_code_object..ror)rrcleaned_instructionsrclean_and_assemble_instructions) rrrr#rr tracer_outputrbytecoder"rr#r)s  rr#cs&t|t|tdd<d}tjdkr&tjfdd|D}|j}t||dd}|rAt |t |t t |}|s1t |t|d\}}tjd krX|d <n|d <|d <t|d <t|dhtdhksxJtjdkrtt|d<|tjfdd|DfS)NrorrNcr:r"r"rrr"r#rxHz3clean_and_assemble_instructions..)rTrr{rrrrrrcr:r"r"rrr"r#rxdr)rirArrerftypesCodeType_varname_from_opargrrrr.ryrrrrr#rr7)rr#rrtmp_codedirtyrrr"rr#r=s:      rconstscCs$|D] }|jdkr||j|_qdS)NKW_NAMES)r2r3r4)rrrgr"r"r#populate_kw_names_argvalgs   rcCst||}t|Sr<)_cached_cleaned_instructions_clone_instructionsrrrr"r"r#ros rcCspdd|D}tt||}d|d<|D]!}||j|_|j}r5t||j||j||j|j|j|_q|S)NcSs>g|]}t|j|j|j|j|j|j|j|j|j |j |j qSr") rr1r2r3r4r5r6r7r9rr:r;rvr"r"r#rxzs z'_clone_instructions..) dictrfrr:rrrrr)rcopiedremaprHrr"r"r#rws"  rcCstttt|}t|t|tjdkr#t ||j t |j |t |t||sbtjdkr6t|tjdkr@t||tjdkr[t|tjdkrRt|tjdkr[t|tjrbt|tjdkrot|t||S)NrNrSrE)rrrLr\get_instructionsrrrerfrrr'rr rCrHrsrRrVrar&debug_force_graph_break_on_leaf_returnrerrrr"r"r#rs2          r with_uuidcCs4|dtt}|r|dtdd7}|S)Nr-)r_unique_id_counteruuiduuid4r)rUrretr"r"r# unique_idsrcCsd}|j|@dkS)N r)r)r co_generatorr"r"r# is_generatorsrfn varname_mapnoreturnnoprefixc Cst|j}t||r#t|D]\}}|jdkr"||dd}nq|D]}d|_d|_|r:|j|vr:||j|_q%|rtj dkrkg}|D]"}|jdkrct j d|_ d|_| || tdqF| |qF|}g}|D] }|jdkr{| |qot|dkr|d|d ur|d |St|dkr|d |d urd |d _t j d |d _ d|d _t|d _|d n| td |D]}t|d } | j|_| j |_ | j|_| j|_| j|_q|S) aGenerates bytecode from a template function `fn` for use in dynamo bytecode generation. For example, we can generate Python-version-independent bytecode for looping through a dictionary and copying the values to a new dictionary. def template(d1, d2): for k, v in d1.items(): d2[k] = v or a try block: def template(): try: dummy1 except: dummy2 raise dummy3 Args: fn: a function template to generate bytecode from varname_map: a mapping of `fn`'s varnames to new names. This map will be applied to the generated bytecode's varnames. For example, local variables in `fn` can be replaced with new names that are generated by `OutputGraph.new_var`. noreturn: remove all RETURN_* bytecodes and replace them with a jump to the end of the bytecode. NOTE: any items pushed to the stack for return WILL remain on the stack! Append a POP_TOP if you don't want that item to be present. noprefix: remove prefix bytecodes (all bytecode before the first RESUME, inclusive). RESUMErNrS RETURN_CONSTrm RETURN_VALUErrzrc)r__code__rrr2r6r9r4rerfr\r]r1rr_rr0r3rPrhr) rrrrrrHrgrEreturns jump_instr"r"r#bytecode_from_templatesb '                 r)T)F)rr<)NTT)rDr% dataclassesr\ functoolsrrerrcollections.abcrrrrtypingrrrr r r utils._backport_slotsr rbytecode_analysisrrrrutilsr output_graphr dataclassrrrfrLrPr/r.rZr-r_rhrjrorsrrrrrrrrrrrrrr$rrrrrrrrrrrrrrr rrrrrrr'r7r9r>rArCrFrHrRrVr\rarerirrsryrrrrrhaslocalrhasnamerhasfreerhasconstrrrr lru_cacherrrrrrrrrrrrr"r"r"r#s          + ' ; 7 /    & % =  "*    7 , M     &!      o,   *%